#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
}