#include <Arduino.h>

void setup() {
    Serial.begin(115200);
    delay(1000);
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.println("STARTING!");
}

void loop() {
    Serial.println("LED: ON (LOW)");
    digitalWrite(LED_BUILTIN, LOW);
    delay(1000);

    Serial.println("LED: OFF (HIGH)");
    digitalWrite(LED_BUILTIN, HIGH);
    delay(1000);
}

#include <Arduino.h>
#include <ESP8266WiFi.h>

#define WIFI_SSID "your ssid"
#define WIFI_PASSWORD "your secure wifi password"

void setup() {
    Serial.begin(115200);
    delay(1000);
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.println("STARTING!");

    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    WiFi.setAutoReconnect(true);
}

const char* getWiFiStatusString(wl_status_t status) {
    switch (status) {
        case WL_NO_SHIELD: return "NO_SHIELD";
        case WL_IDLE_STATUS: return "IDLE_STATUS";
        case WL_NO_SSID_AVAIL: return "NO_SSID_AVAIL";
        case WL_SCAN_COMPLETED: return "SCAN_COMPLETED";
        case WL_CONNECTED: return "CONNECTED";
        case WL_CONNECT_FAILED: return "CONNECT_FAILED";
        case WL_CONNECTION_LOST: return "CONNECTION_LOST";
        case WL_DISCONNECTED: return "DISCONNECTED";
    }
    return "UNKNOWN";
}

wl_status_t wifiStatus = WL_IDLE_STATUS;

void handleWiFiConnect() {
    Serial.println("[WIFI] Connected");
    Serial.print("[WIFI] IP: ");
    Serial.println(WiFi.localIP());
}

void handleWiFiDisconnect() {
    Serial.println("[WIFI] Disconnected");
}

void handleWiFiChange(wl_status_t oldStatus, wl_status_t newStatus) {
    Serial.print("[WIFI] State: ");
    Serial.print(getWiFiStatusString(oldStatus));
    Serial.print(" -> ");
    Serial.println(getWiFiStatusString(newStatus));
}

void loop() {
    wl_status_t newWiFiStatus = WiFi.status();
    if (wifiStatus != newWiFiStatus) {
        wl_status_t oldWiFiStatus = wifiStatus;
        wifiStatus = newWiFiStatus;
        handleWiFiChange(oldWiFiStatus, newWiFiStatus);
        if (newWiFiStatus == WL_CONNECTED)
            handleWiFiConnect();
        if (oldWiFiStatus == WL_CONNECTED)
            handleWiFiDisconnect();
    }

    int delayTimeInms = 1000;
    if (!WiFi.isConnected())
        delayTimeInms = 100;

    Serial.println("[LED] State: ON (LOW)");
    digitalWrite(LED_BUILTIN, LOW);
    delay(delayTimeInms);

    Serial.println("[LED] State: OFF (HIGH)");
    digitalWrite(LED_BUILTIN, HIGH);
    delay(delayTimeInms);
}

#include <Arduino.h>
#include "WiFiManager.h"

#define WIFI_SSID "your neighbor's ssid"
#define WIFI_PASSWORD "your neighbor's phone number"

WiFiManager wifi(WIFI_SSID, WIFI_PASSWORD);

void setup() {
    Serial.begin(115200);
    delay(1000);
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.println("STARTING!");
    wifi.setup();
}

void loop() {
    wifi.loop();

    int delayTimeInms = 1000;
    if (!wifi.isConnected())
        delayTimeInms = 50;

    Serial.println("[LED] State: ON (LOW)");
    digitalWrite(LED_BUILTIN, LOW);
    delay(delayTimeInms);

    Serial.println("[LED] State: OFF (HIGH)");
    digitalWrite(LED_BUILTIN, HIGH);
    delay(delayTimeInms);
}

#ifndef PROJECT_WIFIMANAGER_H
#define PROJECT_WIFIMANAGER_H

#include <ESP8266WiFi.h>

class WiFiManager {
public:
    WiFiManager(const char* newSsid, const char* password);
    void setup();
    void loop();
    bool isConnected();

private:
    const char* ssid;
    const char* password;
    wl_status_t status;
    const char *getStatusString(wl_status_t status);
    void handleConnect();
    void handleDisconnect();
    void handleStatusChange(wl_status_t oldStatus, wl_status_t newStatus);
};


#endif //PROJECT_WIFIMANAGER_H

#include "WiFiManager.h"

WiFiManager::WiFiManager(const char* ssid, const char* password) {
    this->ssid = ssid;
    this->password = password;
    this->status = WL_IDLE_STATUS;
}

const char* WiFiManager::getStatusString(wl_status_t status) {
    switch (status) {
        case WL_NO_SHIELD: return "NO_SHIELD";
        case WL_IDLE_STATUS: return "IDLE_STATUS";
        case WL_NO_SSID_AVAIL: return "NO_SSID_AVAIL";
        case WL_SCAN_COMPLETED: return "SCAN_COMPLETED";
        case WL_CONNECTED: return "CONNECTED";
        case WL_CONNECT_FAILED: return "CONNECT_FAILED";
        case WL_CONNECTION_LOST: return "CONNECTION_LOST";
        case WL_DISCONNECTED: return "DISCONNECTED";
    }
    return "UNKNOWN";
}

void WiFiManager::handleConnect() {
    Serial.println("[WiFiManager] Connected");
    Serial.print("[WiFiManager] IP: ");
    Serial.println(WiFi.localIP());
}

void WiFiManager::handleDisconnect() {
    Serial.println("[WiFiManager] Disconnected");
}

void WiFiManager::handleStatusChange(wl_status_t oldStatus, wl_status_t newStatus) {
    Serial.print("[WiFiManager] State: ");
    Serial.print(getStatusString(oldStatus));
    Serial.print(" -> ");
    Serial.println(getStatusString(newStatus));
}

void WiFiManager::setup() {
    WiFi.begin(ssid, password);
    WiFi.setAutoReconnect(true);
}

void WiFiManager::loop() {
    wl_status_t newWiFiStatus = WiFi.status();
    if (status != newWiFiStatus) {
        wl_status_t oldWiFiStatus = status;
        status = newWiFiStatus;
        handleStatusChange(oldWiFiStatus, newWiFiStatus);
        if (newWiFiStatus == WL_CONNECTED)
            handleConnect();
        if (oldWiFiStatus == WL_CONNECTED)
            handleDisconnect();
    }
}

bool WiFiManager::isConnected() {
    WiFi.isConnected();
}

#include <Arduino.h>
#include "WiFiManager.h"

#define WIFI_SSID "the other neighbor's ssid"
#define WIFI_PASSWORD "1234567890"

WiFiManager wifi(WIFI_SSID, WIFI_PASSWORD);

int delayTimeInms = 1000;

void setup() {
    Serial.begin(115200);
    delay(1000);
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.println("STARTING!");

    wifi.onConnect([&](){ //Be sure to use & to capture the variables by reference
        delayTimeInms = 10000;
    });
    wifi.onDisconnect([&delayTimeInms](){ //You could also capture single variables
        delayTimeInms = 100;
    });
    wifi.onError([&](){
        delayTimeInms = 50;
    });
    wifi.setup();
}

void loop() {
    wifi.loop();

    digitalWrite(LED_BUILTIN, LOW);
    delay(delayTimeInms);

    digitalWrite(LED_BUILTIN, HIGH);
    delay(delayTimeInms);
}

#ifndef PROJECT_WIFIMANAGER_H
#define PROJECT_WIFIMANAGER_H

#include <ESP8266WiFi.h>

class WiFiManager {
public:
    WiFiManager(const char* newSsid, const char* password);
    void onConnect(std::function<void()>);
    void onDisconnect(std::function<void()>);
    void onError(std::function<void()>);
    void setup();
    void loop();
    bool isConnected();

private:
    const char* ssid;
    const char* password;
    wl_status_t status;
    std::function<void()> onConnectHandler;
    std::function<void()> onDisconnectHandler;
    std::function<void()> onErrorHandler;
    const char *getStatusString(wl_status_t status);
    void handleConnect();
    void handleDisconnect();
    void handleError();
    void handleStatusChange(wl_status_t oldStatus, wl_status_t newStatus);
};


#endif //PROJECT_WIFIMANAGER_H

#include "WiFiManager.h"

WiFiManager::WiFiManager(const char* ssid, const char* password) {
    this->ssid = ssid;
    this->password = password;
    this->status = WL_IDLE_STATUS;
}

void WiFiManager::onConnect(std::function<void()> onConnectHandler) {
    this->onConnectHandler = onConnectHandler;
}

void WiFiManager::onDisconnect(std::function<void()> onDisconnectHandler) {
    this->onDisconnectHandler = onDisconnectHandler;
}

void WiFiManager::onError(std::function<void()> onErrorHandler) {
    this->onErrorHandler = onErrorHandler;
}

const char* WiFiManager::getStatusString(wl_status_t status) {
    switch (status) {
        case WL_NO_SHIELD: return "NO_SHIELD";
        case WL_IDLE_STATUS: return "IDLE_STATUS";
        case WL_NO_SSID_AVAIL: return "NO_SSID_AVAIL";
        case WL_SCAN_COMPLETED: return "SCAN_COMPLETED";
        case WL_CONNECTED: return "CONNECTED";
        case WL_CONNECT_FAILED: return "CONNECT_FAILED";
        case WL_CONNECTION_LOST: return "CONNECTION_LOST";
        case WL_DISCONNECTED: return "DISCONNECTED";
    }
    return "UNKNOWN";
}

void WiFiManager::handleConnect() {
    Serial.println("[WiFiManager] Connected");
    Serial.print("[WiFiManager] IP: ");
    Serial.println(WiFi.localIP());

    if (onConnectHandler)
        onConnectHandler();
}

void WiFiManager::handleDisconnect() {
    Serial.println("[WiFiManager] Disconnected");

    if (onDisconnectHandler)
        onDisconnectHandler();
}

void WiFiManager::handleError() {
    Serial.println("[WiFiManager] Error");

    if (onErrorHandler)
        onErrorHandler();
}

void WiFiManager::handleStatusChange(wl_status_t oldStatus, wl_status_t newStatus) {
    Serial.print("[WiFiManager] State: ");
    Serial.print(getStatusString(oldStatus));
    Serial.print(" -> ");
    Serial.println(getStatusString(newStatus));
}

void WiFiManager::setup() {
    WiFi.begin(ssid, password);
    WiFi.setAutoReconnect(true);
}

void WiFiManager::loop() {
    wl_status_t newWiFiStatus = WiFi.status();
    if (status != newWiFiStatus) {
        wl_status_t oldWiFiStatus = status;
        status = newWiFiStatus;
        handleStatusChange(oldWiFiStatus, newWiFiStatus);
        if (newWiFiStatus == WL_CONNECTED)
            handleConnect();
        if (oldWiFiStatus == WL_CONNECTED)
            handleDisconnect();
        if (newWiFiStatus == WL_NO_SHIELD || newWiFiStatus == WL_NO_SSID_AVAIL || newWiFiStatus == WL_CONNECT_FAILED)
            handleError();
    }
}

bool WiFiManager::isConnected() {
    WiFi.isConnected();
}

#include <Arduino.h>
#include "WiFiManager.h"
#include <Hash.h> //Required for ESPAsyncWebServer.h
#include <ESPAsyncWebServer.h>


#define WIFI_SSID "default ssid"
#define WIFI_PASSWORD "random default password"

WiFiManager wifi(WIFI_SSID, WIFI_PASSWORD);

int delayTimeInms = 50;

AsyncWebServer server(80);


void setup() {
    Serial.begin(115200);
    delay(1000);
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.println("STARTING!");

    wifi.onConnect([&](){ //Be sure to use & to capture the variables by reference
        delayTimeInms = 1000;
    });
    wifi.onDisconnect([&delayTimeInms](){ //You could also capture single variables
        delayTimeInms = 50;
    });
    wifi.onError([&](){
        delayTimeInms = 10000;
    });
    wifi.setup();

    server.on("/heap", HTTP_GET, [](AsyncWebServerRequest *request){
        Serial.println("[HTTPServer] Received GET /heap");
        request->send(200, "text/plain", String(ESP.getFreeHeap()));
    });

    server.on("/set", HTTP_GET, [&](AsyncWebServerRequest *request){
        Serial.println("[HTTPServer] Received GET /set");
        AsyncWebParameter* delayTimeInmsParameter = request->getParam("delayTimeInms");
        if (delayTimeInmsParameter) {
            delayTimeInms = delayTimeInmsParameter->value().toInt();
            request->send(200, "text/plain", "OK");
        }
        else {
            request->send(200, "text/plain", "ERROR");
        }
    });

    server.begin();
}

void loop() {
    wifi.loop();

    digitalWrite(LED_BUILTIN, LOW);
    delay(delayTimeInms);

    digitalWrite(LED_BUILTIN, HIGH);
    delay(delayTimeInms);
}