#include <WiFi.h>
#include <PubSubClient.h>

// https://dev.to/emqx/esp32-connects-to-the-free-public-mqtt-broker-386k
// broker --> esp32 ✔
// postman <--> broker ✔ 
// esp32 --> broker ✔

// WiFi
const char *ssid = "Wokwi-GUEST";
const char *password = "";

// MQTT Broker
const char *mqtt_broker = "broker.hivemq.com";
const char *topic = "esp32/test32";
const char *mqtt_username = "emqx";
const char *mqtt_password = "public";
const int mqtt_port = 1883;

WiFiClient espClient;
PubSubClient client(espClient);

const int out05 =  5;        // Status LED
const int out04 =  4;
const int out02 =  2;  

const int output = 5;
const int buttonPin = 15;

void callback(char *topic, byte *payload, unsigned int length) {
 Serial.print("Message arrived in topic: ");
 Serial.println(topic);
 Serial.print("Message:");
 for (int i = 0; i < length; i++) {
     Serial.print((char) payload[i]);
 }
 Serial.println();
 Serial.println("-----------------------");

 // Définissez la chaîne à comparer.
  const char* exempleString = "exemple";

  // Comparez les premiers caractères de payload avec exempleString.
  if (strncmp((char*)payload, exempleString, strlen(exempleString)) == 0) {
      // Faites quelque chose si la comparaison est vraie.
      Serial.println("La chaîne est égale à 'exemple'.");
  } else {
      // Faites quelque chose si la comparaison est fausse.
      Serial.println("La chaîne n'est pas égale à 'exemple'.");
  }
}

void reconnect()
{
    Serial.println("Connecting to MQTT Broker...");
    while (!client.connected()) {
     String client_id = "esp32-client-";
     client_id += String(WiFi.macAddress());
     Serial.printf("The client %s connects to the public mqtt broker\n", client_id.c_str());
     if (client.connect(client_id.c_str(), mqtt_username, mqtt_password)) {
         Serial.println("Public emqx mqtt broker connected");
     } else {
         Serial.print("failed with state ");
         Serial.print(client.state());
         delay(2000);
     }
 }
 // publish and subscribe
 client.publish(topic, "Hi EMQX I'm ESP32 ^^");
 client.subscribe(topic);   
}

void setup() {
 // Set software serial baud to 115200;
 Serial.begin(115200);

 pinMode(out04, OUTPUT);
 pinMode(out02, INPUT_PULLUP);
 digitalWrite(out04, LOW);

 // connecting to a WiFi network
 WiFi.begin(ssid, password);
 while (WiFi.status() != WL_CONNECTED) {
     delay(500);
     Serial.println("Connecting to WiFi..");
 }
 Serial.println("Connected to the WiFi network");
 //connecting to a mqtt broker
 client.setServer(mqtt_broker, mqtt_port);
 client.setCallback(callback);
 while (!client.connected()) {
     String client_id = "esp32-client-";
     client_id += String(WiFi.macAddress());
     Serial.printf("The client %s connects to the public mqtt broker\n", client_id.c_str());
     if (client.connect(client_id.c_str(), mqtt_username, mqtt_password)) {
         Serial.println("Public emqx mqtt broker connected");
     } else {
         Serial.print("failed with state ");
         Serial.print(client.state());
         delay(2000);
     }
 }
 // publish and subscribe
 client.publish(topic, "Hi EMQX I'm ESP32 ^^"); // envoie au début
 client.subscribe(topic);
}

unsigned long last_time;
char data[20];

float pres = 0;
int x;

void loop() {
    if (!client.connected())
        reconnect();
    client.loop();

    x = digitalRead(out02);
    //Serial.println("3 " +  String(x));
   
    digitalWrite(out04, x);   

    long now = millis();
    if (now - last_time > 6000)
    {
        // Send data
        pres+= 1.0;
        // Publishing data throgh MQTT      
        sprintf(data, "%f", pres*(x * 1000));
        Serial.println(data);
        client.publish("/swa/pressure", data);
        last_time = now;
    }
}




/*

#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <ThingsBoard.h>
#include <ArduinoJson.h>

#define GPIO13_PIN 13
#define GPIO12_PIN 12

// Deklarasi Variable dan Konstanta
String wifiSSID = "Wokwi-GUEST";
String wifiPassword = "";

// Thingsboard Credential
String tbHost = "demo.thingsboard.io";
String tbToken = "C9omLqpnmP3BRD5PRbdO";

WiFiClient client;
ThingsBoard tb(client);
PubSubClient mqtt(client);

boolean gpioState[] = {false, false};

// Deklarasi Fungsi
void connectWifi();
String randTemp();
String randHum();
void tbReconnect();
void on_message(const char *topic, byte *payload, unsigned int length);
void set_gpio_status(int pin, boolean enabled);
String get_gpio_status();

void setup()
{
    Serial.begin(9600);
    pinMode(GPIO12_PIN, OUTPUT);
    pinMode(GPIO13_PIN, OUTPUT);
    delay(10);
    connectWifi();
    mqtt.setServer(tbHost.c_str(), 1883);
    mqtt.setCallback(on_message);
}

void loop()
{
    if (!tb.connected())
    {
        tbReconnect();
    }

    float temp = randTemp().toDouble();
    float hum = randHum().toDouble();

    Serial.println("Sending data to Thingsboard");
    tb.sendTelemetryFloat("temperature", temp);
    tb.sendTelemetryFloat("humidity", hum);
    tb.loop();
    mqtt.loop();
    delay(1000);
}

String randTemp()
{
    float randDec = random(0, 99);
    randDec /= 100;
    int randVal = random(25, 30);
    return String(randVal + randDec);
}

String randHum()
{
    float randDec = random(0, 99);
    randDec /= 100;
    int randVal = random(40, 60);
    return String(randVal + randDec);
}

void tbReconnect()
{
    while (!tb.connected())
    {
        if (WiFi.status() != WL_CONNECTED)
        {
            connectWifi();
        }

        Serial.println("connecting to thingsboard ... ");
        if (tb.connect(tbHost.c_str(), tbToken.c_str()))
        {
            //v1/devices/me/rpc/request/$request_id
            mqtt.subscribe("v1/devices/me/rpc/request/+");
            Serial.println("Sending current GPIO status ...");
            mqtt.publish("v1/devices/me/attributes", get_gpio_status().c_str());
            Serial.println("Thingsboard Connected!");
        }
        else
        {
            Serial.println("Thingsboard connection failed");
            Serial.println("Retrying in 5 seconds...");
            delay(5000);
        }
    }
}

void connectWifi()
{
    Serial.println("Connecting To Wifi");
    WiFi.begin(wifiSSID.c_str(), wifiPassword.c_str());
    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(500);
    }

    Serial.println("Wifi Connected");
    Serial.println(WiFi.SSID());
    Serial.println(WiFi.RSSI());
    Serial.println(WiFi.macAddress());
    Serial.println(WiFi.localIP());
    Serial.println(WiFi.gatewayIP());
    Serial.println(WiFi.dnsIP());
}

void on_message(const char *topic, byte *payload, unsigned int length)
{

    Serial.println("On message");

    char json[length + 1];
    strncpy(json, (char *)payload, length);
    json[length] = '\0';

    Serial.print("Topic: ");
    Serial.println(topic);
    Serial.print("Message: ");
    Serial.println(json);
}

String get_gpio_status()
{
    // Prepare gpios JSON payload string
    StaticJsonDocument<200> jsonDoc;
    jsonDoc[String(GPIO13_PIN)] = gpioState[0] ? true : false;
    jsonDoc[String(GPIO12_PIN)] = gpioState[1] ? true : false;

    String json;
    serializeJson(jsonDoc, json);
    Serial.println(json);
    return json;
}
*/