#include "secrets.h" // Contains all the credentials 

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

// Relay Pins
#define Relay1 13  // Corresponding to relay1_pin
#define Relay2 12  // Corresponding to relay2_pin
#define Relay3 14  // Corresponding to relay3_pin

#define button1_pin 26
#define button2_pin 25
#define button3_pin 33
// Define your MQTT subscribe topics
#define AWS_IOT_SUBSCRIBE_TOPIC1 "esp32/relay1"
#define AWS_IOT_SUBSCRIBE_TOPIC2 "esp32/relay2"
#define AWS_IOT_SUBSCRIBE_TOPIC3 "esp32/relay3"

// Define your MQTT publish topics
#define AWS_IOT_PUBLISH_TOPIC "esp32/counter"
#define AWS_IOT_RESPONSE_TOPIC "esp32/response"

WiFiClientSecure net;
PubSubClient client(net);
unsigned long previousMillis = 0;
const long interval = 5000; // 5 seconds interval

int relay1_state = 0;
int relay2_state = 0;
int relay3_state = 0;

void myTimerEvent()
{
  StaticJsonDocument<200> doc;
  doc["message"] = "Hello from ESP32";
  doc["Relay1_State"] = relay1_state;
  doc["Relay2_State"] = relay2_state;
  doc["Relay3_State"] = relay3_state;

  char jsonBuffer[512];
  serializeJson(doc, jsonBuffer); // print to client
  publishMessage(AWS_IOT_PUBLISH_TOPIC, jsonBuffer);
  Serial.println("Message Published");

  // Send response to the app
  sendResponseToApp();
}

void sendResponseToApp()
{
  StaticJsonDocument<200> responseDoc;
  responseDoc["status_relay1"] = relay1_state;
  responseDoc["status_relay2"] = relay2_state;
  responseDoc["status_relay3"] = relay3_state;

  char responseBuffer[512];
  serializeJson(responseDoc, responseBuffer);

  publishMessage(AWS_IOT_RESPONSE_TOPIC, responseBuffer);
}

void publishMessage(const char *topic, const char *message)
{
  client.publish(topic, message);
}

void connectAWS()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  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.print("Connecting to AWS IOT");

  while (!client.connect(THINGNAME))
  {
    Serial.print(".");
    delay(100);
  }

  if (!client.connected())
  {
    Serial.println("AWS IoT Timeout!");
    return;
  }

  // Subscribe to topics
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC1);
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC2);
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC3);

  Serial.println("AWS IoT Connected!");
}

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

  // Parse the JSON payload
  StaticJsonDocument<200> doc;
  deserializeJson(doc, payload);

  // Check if the payload contains the expected keys
  if (doc.containsKey("status"))
  {
    // Process relay status
    int relayStatus = doc["status"];

    if (strstr(topic, "esp32/relay1"))
    {
      relay1_state = relayStatus;
      digitalWrite(Relay1, relay1_state);
      Serial.print("Relay1 - ");
      Serial.println(relay1_state);
    }

    if (strstr(topic, "esp32/relay2"))
    {
      relay2_state = relayStatus;
      digitalWrite(Relay2, relay2_state);
      Serial.print("Relay2 - ");
      Serial.println(relay2_state);
    }

    if (strstr(topic, "esp32/relay3"))
    {
      relay3_state = relayStatus;
      digitalWrite(Relay3, relay3_state);
      Serial.print("Relay3 - ");
      Serial.println(relay3_state);
    }
  }
  else
  {
    Serial.println("Missing relay status in payload. Ignoring...");
  }
}

void setup()
{
  Serial.begin(115200);

  pinMode(button1_pin, INPUT_PULLUP);
  pinMode(button2_pin, INPUT_PULLUP);
  pinMode(button3_pin, INPUT_PULLUP);

  pinMode(Relay1, OUTPUT);
  pinMode(Relay2, OUTPUT);
  pinMode(Relay3, OUTPUT);


  connectAWS();
}

void loop()
{
  
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;
    myTimerEvent();
  }

  if (!client.connected())
  {
    Serial.println("MQTT not connected. Reconnecting...");
    connectAWS();
  }

  // Handle button presses
  listen_push_buttons();

  client.loop();
}

void listen_push_buttons()
{
  if (digitalRead(button1_pin) == LOW)
  {
    delay(200);
    control_relay(1);
  }

  if (digitalRead(button2_pin) == LOW)
  {
    delay(200);
    control_relay(2);
  }

  if (digitalRead(button3_pin) == LOW)
  {
    delay(200);
    control_relay(3);
  }
}

void control_relay(int relay)
{
  if (relay == 1)
  {
    relay1_state = !relay1_state;
    digitalWrite(Relay1, relay1_state);
    Serial.print("Relay1 State = ");
    Serial.println(relay1_state);
    delay(50);
  }
  else if (relay == 2)
  {
    relay2_state = !relay2_state;
    digitalWrite(Relay2, relay2_state);
    delay(50);
  }
  else if (relay == 3)
  {
    relay3_state = !relay3_state;
    digitalWrite(Relay3, relay3_state);
    delay(50);
  }
}