#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

// ---------------------------------------------------------
// Pin Definitions
// ---------------------------------------------------------
#define SENSOR_A_PIN 32 // Outside sensor
#define SENSOR_B_PIN 33 // Inside sensor
#define LED_PIN 2       // Status LED

// ---------------------------------------------------------
// BLE Configuration
// ---------------------------------------------------------
// Generate custom UUIDs using a tool like uuidgenerator.net
#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

BLEServer* pServer = nullptr;
BLECharacteristic* pCharacteristic = nullptr;
bool deviceConnected = false;
bool oldDeviceConnected = false;

// ---------------------------------------------------------
// Application State
// ---------------------------------------------------------
int peopleCount = 0;

enum DirectionState {
    STATE_IDLE,
    STATE_A_BROKEN_FIRST,
    STATE_B_BROKEN_FIRST,
    STATE_WAIT_CLEAR_ENTER,
    STATE_WAIT_CLEAR_EXIT
};

DirectionState currentState = STATE_IDLE;

// ---------------------------------------------------------
// BLE Server Callbacks
// ---------------------------------------------------------
class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
      Serial.println("BLE Client Connected");
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
      Serial.println("BLE Client Disconnected");
    }
};

// ---------------------------------------------------------
// Helper Functions
// ---------------------------------------------------------
void updateBLECount() {
    if (deviceConnected && pCharacteristic != nullptr) {
        // Format the count as a readable string for easy validation
        char countStr[32];
        snprintf(countStr, sizeof(countStr), "Occupancy: %d", peopleCount);
        pCharacteristic->setValue((uint8_t*)countStr, strlen(countStr));
        pCharacteristic->notify();
        Serial.print("BLE Updated: ");
        Serial.println(countStr);
    }
}

void blinkLED() {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
}

// ---------------------------------------------------------
// Setup
// ---------------------------------------------------------
void setup() {
    Serial.begin(115200);
    Serial.println("Starting BLE Doorway People Counter...");

    // Initialize Pins
    pinMode(SENSOR_A_PIN, INPUT_PULLUP);
    pinMode(SENSOR_B_PIN, INPUT_PULLUP);
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW);

    // Initialize BLE
    BLEDevice::init("ESP32_Counter");
    pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    BLEService *pService = pServer->createService(SERVICE_UUID);

    // Create Characteristic with Read and Notify properties
    pCharacteristic = pService->createCharacteristic(
                        CHARACTERISTIC_UUID,
                        BLECharacteristic::PROPERTY_READ   |
                        BLECharacteristic::PROPERTY_NOTIFY
                      );

    // Add CCCD descriptor for notifications
    pCharacteristic->addDescriptor(new BLE2902());

    // Set initial value
    char initStr[32];
    snprintf(initStr, sizeof(initStr), "Occupancy: %d", peopleCount);
    pCharacteristic->setValue((uint8_t*)initStr, strlen(initStr));

    pService->start();

    // Start advertising
    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID(SERVICE_UUID);
    pAdvertising->setScanResponse(false);
    pAdvertising->setMinPreferred(0x0);
    BLEDevice::startAdvertising();

    Serial.println("BLE Advertising started. Waiting for connections...");
}

// ---------------------------------------------------------
// Main Loop
// ---------------------------------------------------------
void loop() {
    // Handle BLE disconnection/reconnection gracefully
    if (!deviceConnected && oldDeviceConnected) {
        delay(500); // Give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); 
        Serial.println("Restarted BLE advertising");
        oldDeviceConnected = deviceConnected;
    }
    if (deviceConnected && !oldDeviceConnected) {
        oldDeviceConnected = deviceConnected;
    }

    // Read sensor states (LOW means the beam is broken)
    bool aBroken = (digitalRead(SENSOR_A_PIN) == LOW);
    bool bBroken = (digitalRead(SENSOR_B_PIN) == LOW);

    // State Machine for Directional Counting
    switch (currentState) {
        case STATE_IDLE:
            if (aBroken && !bBroken) {
                currentState = STATE_A_BROKEN_FIRST;
                Serial.println("State: A Broken (Potential Entry)");
            } else if (bBroken && !aBroken) {
                currentState = STATE_B_BROKEN_FIRST;
                Serial.println("State: B Broken (Potential Exit)");
            }
            break;

        case STATE_A_BROKEN_FIRST:
            // If B breaks while A is or was broken, person is moving forward
            if (bBroken) {
                currentState = STATE_WAIT_CLEAR_ENTER;
                Serial.println("State: B Broken (Completing Entry)");
            } else if (!aBroken && !bBroken) {
                // False alarm, person backed out before breaking B
                currentState = STATE_IDLE;
                Serial.println("State: Idle (False Alarm A)");
            }
            break;

        case STATE_B_BROKEN_FIRST:
            // If A breaks while B is or was broken, person is moving outward
            if (aBroken) {
                currentState = STATE_WAIT_CLEAR_EXIT;
                Serial.println("State: A Broken (Completing Exit)");
            } else if (!aBroken && !bBroken) {
                // False alarm, person backed out before breaking A
                currentState = STATE_IDLE;
                Serial.println("State: Idle (False Alarm B)");
            }
            break;

        case STATE_WAIT_CLEAR_ENTER:
            // Wait for both sensors to clear before counting to avoid multiple counts
            if (!aBroken && !bBroken) {
                peopleCount++;
                Serial.print("Person Entered! Total: ");
                Serial.println(peopleCount);
                updateBLECount();
                blinkLED();
                currentState = STATE_IDLE;
            }
            break;

        case STATE_WAIT_CLEAR_EXIT:
            // Wait for both sensors to clear before counting
            if (!aBroken && !bBroken) {
                if (peopleCount > 0) {
                    peopleCount--;
                }
                Serial.print("Person Exited! Total: ");
                Serial.println(peopleCount);
                updateBLECount();
                blinkLED();
                currentState = STATE_IDLE;
            }
            break;
    }

    // Small delay for debouncing and CPU yield
    delay(20);
}

#include <Arduino.h>

// ---------------------------------------------------------
// Configuration & Constants
// ---------------------------------------------------------
const int ADC_PIN = 34;               // Analog input pin connected to the SCT-013
const float V_REF = 3.3;              // ESP32 ADC reference voltage
const int ADC_RESOLUTION = 4095;      // 12-bit ADC maximum value
const float BURDEN_RESISTOR = 33.0;   // Burden resistor value in Ohms
const float CT_TURNS_RATIO = 2000.0;  // For SCT-013-000: 100A / 0.050A = 2000

void setup() {
    Serial.begin(115200);
    while (!Serial) {
        ; // Wait for serial port to connect
    }

    Serial.println("Dust Collector Current Monitor Initializing...");

    // Configure the ADC pin
    analogReadResolution(12);
    pinMode(ADC_PIN, INPUT);

    Serial.println("Initialization Complete. Monitoring Current...");
}

void loop() {
    unsigned long startMillis = millis();
    double sum = 0;
    double sumSquared = 0;
    int samples = 0;

    // Sample the waveform for 200ms (captures 10-12 full AC cycles)
    while (millis() - startMillis < 200) {
        int raw = analogRead(ADC_PIN);
        sum += raw;
        sumSquared += ((double)raw * raw);
        samples++;

        // Small delay to prevent FreeRTOS watchdog starvation
        delayMicroseconds(100); 
    }

    if (samples > 0) {
        // Calculate the statistical variance of the samples
        // Variance = E[X^2] - (E[X])^2
        double mean = sum / samples;
        double meanSquared = sumSquared / samples;
        double variance = meanSquared - (mean * mean);

        // Prevent negative variance due to floating point inaccuracies
        if (variance < 0) {
            variance = 0;
        }

        // RMS of the AC component is the square root of the variance
        double rmsAdc = sqrt(variance);

        // Convert ADC units to Voltage
        double rmsVoltage = (rmsAdc / ADC_RESOLUTION) * V_REF;

        // Convert Voltage to Primary Current using burden resistor and turns ratio
        double rmsCurrent = (rmsVoltage / BURDEN_RESISTOR) * CT_TURNS_RATIO;

        // Noise suppression: clamp extremely low floating values to 0
        if (rmsCurrent < 0.15) {
            rmsCurrent = 0.0;
        }

        // Print the calculated RMS current to the Serial Monitor
        Serial.print("Samples: ");
        Serial.print(samples);
        Serial.print(" | Dust Collector Current Draw: ");
        Serial.print(rmsCurrent, 2); // Print with 2 decimal places
        Serial.println(" A");
    }

    // Delay before the next sampling window
    delay(800);
}

#include <Arduino.h>
#include <WiFi.h>
#include <WebServer.h>

// ---------------------------------------------------------
// Pin Definitions
// ---------------------------------------------------------
const int RELAY_PIN = 26;
const int LOW_FLOAT_PIN = 27;
const int HIGH_FLOAT_PIN = 14;

// ---------------------------------------------------------
// State Variables
// ---------------------------------------------------------
bool pumpIsOn = false;
bool lowFloatActive = false;  // true = tank empty (dry run risk)
bool highFloatActive = false; // true = tank full

// ---------------------------------------------------------
// Network & Web Server Setup
// ---------------------------------------------------------
const char* AP_SSID = "ESP32_Pump_Guard";
const char* AP_PASS = "admin1234";

WebServer server(80);

// ---------------------------------------------------------
// HTML Dashboard (Stored in PROGMEM)
// ---------------------------------------------------------
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pump Dry-Run Guard</title>
    <style>
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f4f7f6; color: #333; text-align: center; margin: 0; padding: 20px; }
        .card { background: white; padding: 20px; border-radius: 10px; box-shadow: 0 4px 8px rgba(0,0,0,0.1); max-width: 500px; margin: 0 auto 20px auto; }
        h1 { color: #2c3e50; }
        .status-badge { display: inline-block; padding: 8px 15px; border-radius: 20px; font-weight: bold; color: white; margin-bottom: 10px; }
        .bg-green { background-color: #27ae60; }
        .bg-red { background-color: #e74c3c; }
        .bg-gray { background-color: #7f8c8d; }
        button { padding: 12px 24px; font-size: 16px; margin: 10px; border: none; border-radius: 5px; cursor: pointer; transition: 0.3s; color: white; font-weight: bold;}
        .btn-on { background-color: #3498db; }
        .btn-on:hover { background-color: #2980b9; }
        .btn-off { background-color: #95a5a6; }
        .btn-off:hover { background-color: #7f8c8d; }
        .data-row { display: flex; justify-content: space-between; padding: 10px 0; border-bottom: 1px solid #eee; }
        .data-row:last-child { border-bottom: none; }
    </style>
</head>
<body>
    <div class="card">
        <h1>Pump Controller</h1>
        <div id="guard-badge" class="status-badge bg-gray">Loading Status...</div>

        <div class="data-row">
            <span>Tank Level:</span>
            <strong id="tank-level">Unknown</strong>
        </div>
        <div class="data-row">
            <span>Pump State:</span>
            <strong id="pump-state">Unknown</strong>
        </div>

        <div style="margin-top: 20px;">
            <button class="btn-on" onclick="controlPump('on')">Start Pump</button>
            <button class="btn-off" onclick="controlPump('off')">Stop Pump</button>
        </div>
    </div>

    <script>
        function updateDashboard() {
            fetch('/api/status')
                .then(response => response.json())
                .then(data => {
                    document.getElementById('tank-level').innerText = data.tank_status;
                    document.getElementById('pump-state').innerText = data.pump_on ? "RUNNING" : "STOPPED";
                    const badge = document.getElementById('guard-badge');
                    if (data.dry_run_guard) {
                        badge.innerText = "DRY RUN GUARD ACTIVE";
                        badge.className = "status-badge bg-red";
                    } else {
                        badge.innerText = "SYSTEM SAFE";
                        badge.className = "status-badge bg-green";
                    }
                })
                .catch(err => console.error('Error fetching status:', err));
        }

        function controlPump(action) {
            fetch('/api/pump?state=' + action, { method: 'POST' })
                .then(response => response.json())
                .then(data => {
                    if (data.error) {
                        alert("Command rejected: " + data.error);
                    }
                    updateDashboard();
                });
        }

        setInterval(updateDashboard, 2000);
        updateDashboard();
    </script>
</body>
</html>
)rawliteral";

// ---------------------------------------------------------
// Helper Functions
// ---------------------------------------------------------
void updateSensorStates() {
    // Switch Open (Float down/Empty) -> Pin is HIGH
    // Switch Closed (Float up/Water present) -> Pin is LOW
    lowFloatActive = (digitalRead(LOW_FLOAT_PIN) == HIGH); 
    highFloatActive = (digitalRead(HIGH_FLOAT_PIN) == LOW); 

    // Hardware Dry-Run Override Protection
    if (lowFloatActive && pumpIsOn) {
        Serial.println("CRITICAL: Dry run detected! Forcing pump OFF.");
        pumpIsOn = false;
        digitalWrite(RELAY_PIN, LOW); // Turn off relay safely
    }
}

String getTankStatusString() {
    if (lowFloatActive) return "Empty (Low Level)";
    if (highFloatActive) return "Full (High Level)";
    return "Normal (Mid Level)";
}

// ---------------------------------------------------------
// Web Server Route Handlers
// ---------------------------------------------------------
void handleRoot() {
    server.send(200, "text/html", index_html);
}

void handleApiStatus() {
    updateSensorStates();

    String json = "{";
    json += "\"pump_on\":" + String(pumpIsOn ? "true" : "false") + ",";
    json += "\"tank_status\":\"" + getTankStatusString() + "\",";
    json += "\"dry_run_guard\":" + String(lowFloatActive ? "true" : "false");
    json += "}";

    server.send(200, "application/json", json);
}

void handleApiPump() {
    if (!server.hasArg("state")) {
        server.send(400, "application/json", "{\"error\":\"Missing state argument\"}");
        return;
    }

    String stateArg = server.arg("state");
    updateSensorStates();

    if (stateArg == "on") {
        if (lowFloatActive) {
            Serial.println("API: Pump ON command rejected. Dry run guard is active.");
            server.send(403, "application/json", "{\"error\":\"Dry run guard active. Tank is empty.\"}");
            return;
        } else {
            pumpIsOn = true;
            digitalWrite(RELAY_PIN, HIGH);
            Serial.println("API: Pump turned ON manually.");
        }
    } else if (stateArg == "off") {
        pumpIsOn = false;
        digitalWrite(RELAY_PIN, LOW);
        Serial.println("API: Pump turned OFF manually.");
    }

    handleApiStatus();
}

// ---------------------------------------------------------
// Main Setup & Loop
// ---------------------------------------------------------
void setup() {
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n--- ESP32 Water Pump Dry-Run Guard ---");

    // Initialize Pins
    pinMode(RELAY_PIN, OUTPUT);
    digitalWrite(RELAY_PIN, LOW); // Ensure pump is OFF at boot

    // Use internal pull-ups for float switches
    pinMode(LOW_FLOAT_PIN, INPUT_PULLUP);
    pinMode(HIGH_FLOAT_PIN, INPUT_PULLUP);

    // Setup WiFi Access Point
    Serial.print("Setting up WiFi AP...");
    WiFi.softAP(AP_SSID, AP_PASS);

    Serial.println("Done.");
    Serial.print("AP IP Address: ");
    Serial.println(WiFi.softAPIP());

    // Configure Web Server Routes
    server.on("/", handleRoot);
    server.on("/api/status", handleApiStatus);
    server.on("/api/pump", HTTP_POST, handleApiPump);

    server.begin();
    Serial.println("HTTP server started.");
}

void loop() {
    server.handleClient();
    updateSensorStates();
    delay(50); // Small yield to prevent watchdog starvation
}

#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>

// ==========================================
// Configuration
// ==========================================
const char* WIFI_SSID     = "IoT_Network";
const char* WIFI_PASSWORD = "SecurePassword123";
const char* WEBHOOK_URL   = "http://192.168.1.100/mailbox-alert";

// Pin Definitions
const gpio_num_t REED_SWITCH_PIN = GPIO_NUM_33; // Must be an RTC GPIO for ext0 wakeup

// Timeouts
const int WIFI_TIMEOUT_MS = 10000; // 10 seconds max to connect

// ==========================================
// Helper Functions
// ==========================================

void printWakeupReason() {
    esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
    switch(wakeup_reason) {
        case ESP_SLEEP_WAKEUP_EXT0:     
            Serial.println("Wakeup caused by external signal using RTC_IO (Door Opened!)"); 
            break;
        case ESP_SLEEP_WAKEUP_TIMER:    
            Serial.println("Wakeup caused by timer"); 
            break;
        default:                        
            Serial.printf("Wakeup was not caused by deep sleep: %d\n", wakeup_reason); 
            break;
    }
}

void sendAlert() {
    Serial.print("Connecting to Wi-Fi: ");
    Serial.println(WIFI_SSID);

    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

    unsigned long startAttemptTime = millis();

    // Wait for connection with a timeout to prevent draining battery
    while (WiFi.status() != WL_CONNECTED && millis() - startAttemptTime < WIFI_TIMEOUT_MS) {
        Serial.print(".");
        delay(500);
    }

    Serial.println();

    if (WiFi.status() != WL_CONNECTED) {
        Serial.println("Failed to connect to Wi-Fi. Going back to sleep.");
        return; // Abort and let the main loop put the device to sleep
    }

    Serial.println("Wi-Fi connected!");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());

    // Send HTTP GET request
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        Serial.print("Sending alert to: ");
        Serial.println(WEBHOOK_URL);

        http.begin(WEBHOOK_URL);
        int httpResponseCode = http.GET();

        if (httpResponseCode > 0) {
            Serial.print("HTTP Response code: ");
            Serial.println(httpResponseCode);
        } else {
            Serial.print("Error code: ");
            Serial.println(httpResponseCode);
        }
        http.end();
    }

    // Disconnect Wi-Fi to save power before sleeping
    WiFi.disconnect(true);
    WiFi.mode(WIFI_OFF);
}

// ==========================================
// Main Setup and Loop
// ==========================================

void setup() {
    Serial.begin(115200);
    delay(1000); // Allow serial monitor to catch up

    Serial.println("\n--- Mailbox Monitor Booting ---");

    // Determine why the ESP32 woke up
    esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
    printWakeupReason();

    // If woke up because the door opened (EXT0)
    if (wakeup_reason == ESP_SLEEP_WAKEUP_EXT0) {
        sendAlert();
    } else {
        // Normal boot (e.g., first power on or reset)
        Serial.println("Initial boot. System is armed and ready.");
    }

    // Configure Deep Sleep Wakeup
    // Door open = magnet away = switch open = pull-down resistor pulls to LOW (0).
    // Wake up when GPIO 33 goes LOW (0).
    esp_sleep_enable_ext0_wakeup(REED_SWITCH_PIN, 0); 

    Serial.println("Entering deep sleep now. Waiting for door to open...");
    Serial.flush(); 

    // Enter Deep Sleep
    esp_deep_sleep_start();
}

void loop() {
    // The loop is intentionally empty.
    // The ESP32 goes to sleep in setup() and resets entirely upon waking.
}

#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>

// ---------------------------------------------------------
// Configuration: WiFi & Webhook
// ---------------------------------------------------------
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

// For demonstration, we use httpbin.org to echo the GET request.
// In a real application, replace this with an IFTTT Webhook, 
// Home Assistant endpoint, or custom API URL.
const char* WEBHOOK_URL = "http://httpbin.org/get?laundry=finished";

// ---------------------------------------------------------
// Configuration: Hardware Pins
// ---------------------------------------------------------
const int SW420_PIN = 13;
const int BUZZER_PIN = 14;
const int LED_PIN = 27;

// ---------------------------------------------------------
// Configuration: Timing & State Machine
// ---------------------------------------------------------
// Time required without vibration to consider the cycle "finished".
// Set to 15 seconds (15000ms) for testing. 
// For real laundry machines, use 180000ms (3 minutes) or more.
const unsigned long CYCLE_TIMEOUT_MS = 15000; 

enum MachineState {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_FINISHED
};

MachineState currentState = STATE_IDLE;
unsigned long lastVibrationTime = 0;
unsigned long lastAlertToggleTime = 0;
bool alertToggleState = false;

// Function prototypes
void connectToWiFi();
void sendWiFiAlert();
void handleAlertHardware();

void setup() {
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n--- Laundry Vibration WiFi Alert ---");

    // Initialize pins
    pinMode(SW420_PIN, INPUT);
    pinMode(BUZZER_PIN, OUTPUT);
    pinMode(LED_PIN, OUTPUT);

    // Ensure outputs are off initially
    digitalWrite(BUZZER_PIN, LOW);
    digitalWrite(LED_PIN, LOW);

    connectToWiFi();

    Serial.println("System initialized. Waiting for vibration...");
}

void loop() {
    unsigned long currentMillis = millis();
    int vibrationDetected = digitalRead(SW420_PIN);

    // 1. Read Sensor & Update Timers
    if (vibrationDetected == HIGH) {
        lastVibrationTime = currentMillis;

        // If we were idle or already finished, a new vibration means a cycle is starting/restarting
        if (currentState == STATE_IDLE || currentState == STATE_FINISHED) {
            currentState = STATE_RUNNING;
            Serial.println("STATUS: Machine is now RUNNING.");
            // Ensure alert hardware is turned off when returning to running
            digitalWrite(BUZZER_PIN, LOW);
            digitalWrite(LED_PIN, HIGH); // Solid LED indicates running
        }
    }

    // 2. Evaluate State Machine
    if (currentState == STATE_RUNNING) {
        // Check if the timeout has elapsed since the last detected vibration
        if (currentMillis - lastVibrationTime > CYCLE_TIMEOUT_MS) {
            currentState = STATE_FINISHED;
            Serial.println("STATUS: Cycle FINISHED! Triggering alerts.");
            digitalWrite(LED_PIN, LOW); // Turn off solid LED
            sendWiFiAlert();
        }
    }

    // 3. Handle Hardware Outputs based on State
    if (currentState == STATE_FINISHED) {
        handleAlertHardware();
    } else if (currentState == STATE_IDLE) {
        // Optional: Pulse LED slowly to show system is alive but idle
        digitalWrite(LED_PIN, (currentMillis / 1000) % 2 == 0);
    }

    // Small delay to prevent tight-loop debouncing issues
    delay(50);
}

// ---------------------------------------------------------
// Helper Functions
// ---------------------------------------------------------

void connectToWiFi() {
    Serial.print("Connecting to WiFi: ");
    Serial.println(WIFI_SSID);

    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
        delay(500);
        Serial.print(".");
        attempts++;
    }

    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\nWiFi connected.");
        Serial.print("IP Address: ");
        Serial.println(WiFi.localIP());
    } else {
        Serial.println("\nFailed to connect to WiFi. Continuing offline.");
    }
}

void sendWiFiAlert() {
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        Serial.print("Sending HTTP GET to: ");
        Serial.println(WEBHOOK_URL);

        http.begin(WEBHOOK_URL);
        int httpResponseCode = http.GET();

        if (httpResponseCode > 0) {
            Serial.print("HTTP Response code: ");
            Serial.println(httpResponseCode);
        } else {
            Serial.print("Error code: ");
            Serial.println(httpResponseCode);
        }
        http.end();
    } else {
        Serial.println("WiFi disconnected. Cannot send webhook alert.");
    }
}

void handleAlertHardware() {
    // Non-blocking toggle for Buzzer and LED (beep every 500ms)
    unsigned long currentMillis = millis();
    if (currentMillis - lastAlertToggleTime >= 500) {
        lastAlertToggleTime = currentMillis;
        alertToggleState = !alertToggleState;

        digitalWrite(BUZZER_PIN, alertToggleState ? HIGH : LOW);
        digitalWrite(LED_PIN, alertToggleState ? HIGH : LOW);
    }
}

#include <Arduino.h>
#include <WiFi.h>
#include <WebServer.h>
#include <SPI.h>
#include <SD.h>
#include <time.h>

// ==========================================
// Configuration Parameters
// ==========================================
#define WIFI_SSID "Facility_IoT_Network"
#define WIFI_PASS "SecureWLAN2024"

#define PIN_SD_CS 5
#define PIN_CONTACT 4

const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 0;        
const int   daylightOffset_sec = 3600; 

const char* logFilePath = "/log.csv";

// ==========================================
// Global Variables
// ==========================================
WebServer server(80);

int contactState = HIGH;
int lastContactState = HIGH;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50; // 50ms debounce claim

// ==========================================
// Helper Functions
// ==========================================

String getTimeString() {
    struct tm timeinfo;
    if (!getLocalTime(&timeinfo)) {
        return "1970-01-01 00:00:00";
    }
    char timeStringBuff[50];
    strftime(timeStringBuff, sizeof(timeStringBuff), "%Y-%m-%d %H:%M:%S", &timeinfo);
    return String(timeStringBuff);
}

void logEventToSD(const String& message) {
    File file = SD.open(logFilePath, FILE_APPEND);
    if (!file) {
        Serial.println("Error: Failed to open log file for appending.");
        return;
    }
    if (file.println(message)) {
        Serial.println("Event logged successfully: " + message);
    } else {
        Serial.println("Error: File append operation failed.");
    }
    file.close();
}

// ==========================================
// Web Server Handlers
// ==========================================

void handleRoot() {
    String html = "<!DOCTYPE html><html><head><title>ESP32 Logger Dashboard</title>";
    html += "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">";
    html += "<style>body{font-family:Arial,sans-serif; margin:40px; background-color:#f4f4f9;}";
    html += "h1{color:#333;} .btn{display:inline-block; padding:10px 20px; ";
    html += "background-color:#0056b3; color:white; text-decoration:none; border-radius:5px;}</style></head><body>";
    html += "<h1>ESP32 Industrial Contact Logger</h1>";
    html += "<p>System Status: ONLINE</p>";
    html += "<p>Storage Status: MOUNTED</p>";
    html += "<a href=\"/log.csv\" class=\"btn\">Download CSV Log</a>";
    html += "</body></html>";

    server.send(200, "text/html", html);
}

void handleLogDownload() {
    if (!SD.exists(logFilePath)) {
        server.send(404, "text/plain", "Error 404: Log file not found. No events recorded yet.");
        return;
    }

    File file = SD.open(logFilePath, FILE_READ);
    if (!file) {
        server.send(500, "text/plain", "Error 500: Internal Server Error. Failed to open log file.");
        return;
    }

    server.streamFile(file, "text/csv");
    file.close();
}

// ==========================================
// Setup and Loop
// ==========================================

void setup() {
    Serial.begin(115200);
    while (!Serial) { delay(10); } 

    pinMode(PIN_CONTACT, INPUT_PULLUP);

    Serial.println("\n--- ESP32 Contact Logger Initializing ---");

    if (!SD.begin(PIN_SD_CS)) {
        Serial.println("CRITICAL ERROR: SD Card Mount Failed. System halted.");
        while (true) { delay(1000); }
    }
    Serial.println("SD Card mounted successfully.");

    if (!SD.exists(logFilePath)) {
        File file = SD.open(logFilePath, FILE_WRITE);
        if (file) {
            file.println("Timestamp,Event");
            file.close();
            Serial.println("Created new log.csv with headers.");
        }
    }

    Serial.print("Connecting to WiFi network: ");
    Serial.println(WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);

    int wifiAttempts = 0;
    while (WiFi.status() != WL_CONNECTED && wifiAttempts < 20) {
        delay(500);
        Serial.print(".");
        wifiAttempts++;
    }

    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\nWiFi connected.");
        Serial.print("Assigned IP Address: ");
        Serial.println(WiFi.localIP());

        configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
        Serial.println("Awaiting NTP time synchronization...");
        delay(2000); 
    } else {
        Serial.println("\nWARNING: WiFi connection failed. Timestamps will default to epoch.");
    }

    server.on("/", handleRoot);
    server.on("/log.csv", HTTP_GET, handleLogDownload);
    server.begin();
    Serial.println("HTTP server started and listening on port 80.");
}

void loop() {
    server.handleClient();

    int reading = digitalRead(PIN_CONTACT);

    if (reading != lastContactState) {
        lastDebounceTime = millis();
    }

    if ((millis() - lastDebounceTime) > debounceDelay) {
        if (reading != contactState) {
            contactState = reading;

            if (contactState == LOW) {
                String timeStr = getTimeString();
                String logEntry = timeStr + ",Contact Closed";
                logEventToSD(logEntry);
            }
        }
    }

    lastContactState = reading;
}