#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <WiFi.h>
#include <secrets.h>

#define AWS_IOT_PUBLISH_TOPIC   "MQTTconexion/nodered"
#define AWS_IOT_SUBSCRIBE_TOPIC "MQTTconexion/nodered"
#define NODE_RED_MQTT_BROKER    "test.mosquitto.org"
#define NODE_RED_MQTT_PORT      1883
#define NODE_RED_MQTT_TOPIC     "/status"

const int ledIdle = 14;
const int ledRinging = 13;
const int ledInUse = 12;

WiFiClientSecure net;
PubSubClient client(net);
WiFiClient nodeRedClient;
PubSubClient cliente(nodeRedClient);

void connectAWS()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin("Wokwi-GUEST", "");

  Serial.println("Connecting to Wi-Fi");

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }

  // Configure WiFiClientSecure to use the AWS IoT device credentials
  net.setCACert(AWS_CERT_CA);
  net.setCertificate(AWS_CERT_CRT);
  net.setPrivateKey(AWS_CERT_PRIVATE);

  // Connect to the MQTT broker on the AWS endpoint we defined earlier
  client.setServer(AWS_IOT_ENDPOINT, 8883);

  // Create a message handler
  client.setCallback(messageHandler);

  Serial.println("Connecting to AWS IoT");

  while (!client.connected())
  {
    Serial.print(".");
    if (client.connect(THINGNAME))
    {
      Serial.println("Connected to AWS IoT");
      client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
    }
    else
    {
      Serial.println("AWS IoT Connection Failed! Retrying...");
      delay(1000);
    }
  }
}

void connectNodeRed()
{
  cliente.setServer(NODE_RED_MQTT_BROKER, NODE_RED_MQTT_PORT);
  cliente.setCallback(nodeRedMessageHandler);

  Serial.println("Connecting to Node-RED MQTT broker");

  while (!cliente.connected())
  {
    Serial.print(".");
    if (cliente.connect("ESP32"))
    {
      Serial.println("Connected to Node-RED MQTT broker");
      cliente.subscribe(NODE_RED_MQTT_TOPIC);
    }
    else
    {
      Serial.println("Node-RED MQTT Connection Failed! Retrying...");
      delay(1000);
    }
  }
}

void messageHandler(char* topic, byte* payload, unsigned int length)
{
  Serial.print("Incoming message from topic: ");
  Serial.println(topic);

  StaticJsonDocument<200> doc;
  deserializeJson(doc, payload, length);
  const char* message = doc["message"];
  Serial.println(message);
}

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

  String mensaje;
  for (int i = 0; i < length; i++) {
    mensaje += (char)payload[i];
  }
if (mensaje != "running") {
    // Enviar mensaje a IoT AWS como "Idle"
    StaticJsonDocument<200> doc;
    doc["message"] = mensaje;
        if (mensaje == "Idle") {
      digitalWrite(ledIdle, HIGH);
      digitalWrite(ledRinging, LOW);
      digitalWrite(ledInUse, LOW);
    } else if (mensaje == "Ringing") {
      digitalWrite(ledIdle, LOW);
      digitalWrite(ledRinging, HIGH);
      digitalWrite(ledInUse, LOW);
    } else if (mensaje= "InUse") {
      digitalWrite(ledIdle, LOW);
      digitalWrite(ledRinging, LOW);
      digitalWrite(ledInUse, HIGH);
    }
    char jsonBuffer[512];
    serializeJson(doc, jsonBuffer);
    client.publish(AWS_IOT_PUBLISH_TOPIC, jsonBuffer);
    Serial.println(mensaje);
  } else {
    // No enviar nada a IoT AWS si el mensaje no coincide con los estados conocidos
    Serial.println("Mensaje desconocido, no se envía a IoT AWS");
  }
}
void setup()
{
  Serial.begin(115200);
  connectAWS();
  connectNodeRed();
}

void loop()
{
  client.loop();
  cliente.loop();
  delay(1000);
}