#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <DHT.h>
#include <time.h>
#include "WiFiClientSecure.h"
#include <WiFiUdp.h>

const static char *ca_cert ="-----BEGIN CERTIFICATE-----\n" \
"MIICHTCCAcCgAwIBAgIEYXef6zAMBggqhkjOPQQDAgUAMHUxCzAJBgNVBAYTAklS\n" \
"MQ0wCwYDVQQIEwRGYXJzMQ8wDQYDVQQHEwZTaGlyYXoxIjAgBgNVBAoTGVRhaGxp\n" \
"bGdhcmFuIFphbWFuIEJhc2FtYWQxCzAJBgNVBAsTAkNBMRUwEwYDVQQDEwxtcXR0\n" \
"LnFzdW4uaW8wIBcNMjQwOTMwMTEzNTA0WhgPMjA1MjAyMTUxMTM1MDRaMHUxCzAJ\n" \
"BgNVBAYTAklSMQ0wCwYDVQQIEwRGYXJzMQ8wDQYDVQQHEwZTaGlyYXoxIjAgBgNV\n" \
"BAoTGVRhaGxpbGdhcmFuIFphbWFuIEJhc2FtYWQxCzAJBgNVBAsTAkNBMRUwEwYD\n" \
"VQQDEwxtcXR0LnFzdW4uaW8wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASCAH4Q\n" \
"k0KPQHUuQtDeVPfq3fMG6JITtbb6hq0MwUa/ZCovGZ9wDuveySViM5ZHkeNif2Jy\n" \
"u4bUCwrWC1fUvq+rozowODAdBgNVHQ4EFgQU0hDhrVGLE1HABL9fB1HASW5FJh8w\n" \
"FwYDVR0RBBAwDoIMbXF0dC5xc3VuLmlvMAwGCCqGSM49BAMCBQADSQAwRgIhALEo\n" \
"MufnBPdw9u1aspHJJCa6fsevLRtY5tVyq/yk8ursAiEAvLIRjEAY9zEjTH2MoNlH\n" \
"K3Ld+tGov1gh+iPzSG1Pbus=\n" \
"-----END CERTIFICATE-----\n";


static StaticJsonDocument<128> jsonPubDoc;

int year = 2024;
int month = 10;    
int day = 13;
int hour = 5;     
int minute = 30;
int second = 0;

// Function to calculate UNIX timestamp (ts)
unsigned long long calculateUnixTime(int year, int month, int day, int hour, int minute, int second) {
  // This function calculates the UNIX timestamp in seconds for the given date and time
  second=second+10;
  minute=minute+1;
  struct tm t;
  t.tm_year = year- 1900;   // tm_year is years since 1900
  t.tm_mon = month - 1 ;      // tm_mon is months since January (0-11)
  t.tm_mday = day;
  t.tm_hour = hour;
  t.tm_min = minute;
  t.tm_sec = second;
  t.tm_isdst = 0;  // Let the system determine if Daylight Saving Time is in effect

  return mktime(&t);
}

unsigned long lastMsg = 0;
// WiFi credentials
const char* ssid = "Wokwi-GUEST";
const char* password = "";

// ThingsBoard credentials
//const char* mqtt_server = "demo.thingsboard.io"; // e.g., "demo.thingsboard.io" for the demo instance
const char* mqtt_server = "mqtt.qsun.io";
const int mqtt_port = 8883; // Default MQTT port
//const char* token = "weqZxVvFU0haKKW52RVo"; // Device access token from ThingsBoard
const char* token = "CyL749W5xrq7YnQs8lHn";
// DHT sensor settings
#define DHTPIN 12     // Digital pin connected to the DHT sensor
#define DHTTYPE DHT22   // DHT 22 (AM2302)
DHT dht(DHTPIN, DHTTYPE);

const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 0;

WiFiClientSecure espClient;
PubSubClient client(espClient);

void sendRPCRequest() {
  StaticJsonDocument<128> doc;
  doc["method"] = "SWSetValue";  // RPC Method defined in ThingsBoard for the knob
  doc["params"] = "";             // No parameters required for this request

  char jsonBuffer[128];
  serializeJson(doc, jsonBuffer);

  // Publish the RPC request to ThingsBoard
  static int requestId = 1;  // Increment for each request
  String topic = "v1/devices/me/rpc/request/" + String(requestId++);
  if (client.publish(topic.c_str(), jsonBuffer)) {
    Serial.println("RPC request sent successfully! request: "+ String(requestId));
  } else {
    Serial.println("Failed to send RPC request.");
  }
}

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

  StaticJsonDocument<256> doc;
    DeserializationError error = deserializeJson(doc, payload, length);
    if (error) {
        Serial.print("JSON deserialization failed: ");
        Serial.println(error.c_str());
        return;
    }

    // Extract "method" and "params"
    const char* method = doc["method"];
    

    // Check for the SWSetValue RPC method
    if (strcmp(method, "SWSetValue") == 0) {
      bool value = doc["params"]; // Assuming "params" is True/False
      Serial.println("SWSetValue RPC received!");
      Serial.print("Value: ");
      Serial.println(value ? "True" : "False");

      // Handle the switch control (e.g., toggle a GPIO pin)
      //digitalWrite(LED_BUILTIN, value ? HIGH : LOW); // Example: control built-in LED
    }else if (strcmp(method, "KnobSetValue") == 0 || strcmp(method, "KnobGetValue") == 0) {
      float value = doc["params"]; // Assuming "params" is float
      Serial.println("knobSetValue RPC received!");
      Serial.print("Value: ");
      Serial.println(value);
    }else if (strcmp(method, "setButtonStatus") == 0) {
      String value = doc["params"]; // Assuming "params" is string
      Serial.println("knobSetValue RPC received!");
      Serial.print("Value: ");
      Serial.println(value);
    } else if (String(topic).startsWith("v1/devices/me/rpc/response/")) {
        if (doc.containsKey("params")) {
          bool knobValue = doc["params"];  // Get the knob value
          Serial.print("Knob Value Received: ");
          Serial.println(knobValue ? "True" : "False");
          // Handle the knob value here (e.g., adjust device settings)
        }
      } else {
        Serial.println("Unknown RPC method received.");
        Serial.println(method);
      }


  // DynamicJsonDocument doc(1024);
  // deserializeJson(doc, message);
  // String method = doc["method"];

  // if (method == "setTemperature") {
  //   float temperature = doc["params"]["temperature"];
  //   Serial.print("Received Temperature: ");
  //   Serial.println(temperature);
  //   // Add your code here to handle the received temperature value
  // }
  // if (method == "setButtonStatus") {
  //   bool stat = doc["params"]["stat"];
  //   Serial.print("Received Temperature: ");
  //   Serial.println(temperature);
  //   // Add your code here to handle the received temperature value
  // }
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

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

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

static void publishToCloud(void)
{
  static uint32_t cntr;
  char pubBuff[128];
  Serial.println("Publish Now");
  jsonPubDoc["TestCntr"] = cntr++;
  serializeJson(jsonPubDoc, pubBuff);
  client.publish("v1/devices/me/telemetry", (const uint8_t*)pubBuff, 1, false);
  Serial.println("Publish succeeded");
  String topic = "v1/devices/me/telemetry";
  String message = String(topic) + pubBuff;
  Serial.println(message);
  
}

void publishToThingsBoard() {

  
  unsigned long long epochTime = calculateUnixTime(year, month, day, hour, minute, second) * 1000;  // Convert to milliseconds

  
  int randomNumber = random(20, 41);
  //for time sending
  // String payload = "{";
  // //payload += "\"temperature\":"+String(randomNumber)+"";  // Example telemetry data
  //   payload +="\"ts\":" + String(epochTime) + ", \"values\": {\"time\": " + String(epochTime) + "";
  //   payload += ",\"temperature\":"+String(randomNumber);
  //   payload +=",\"ar\":24";
  //   payload +="}";  // Example telemetry data
  // payload += "}";


//without time
 String payload = "{";
  //payload += "\"temperature\":"+String(randomNumber)+"";  // Example telemetry data

    payload += "\"temperature\":"+String(randomNumber);
    payload +=",\"pressure\":24";
     
  payload += "}";

  Serial.print("Publishing payload: ");
  Serial.println(payload);

  if (client.publish("v1/devices/me/telemetry", (char*) payload.c_str())) {
    Serial.println("Publish succeeded");
  } else {
    Serial.println("Publish failed");
  }
}

static void serverConnect(void) //mqtt connect
{
  /* Loop until reconnected */
  while (!client.connected())
  {
    Serial.print("MQTT connecting ...");
    /* connect now */
    if (client.connect("ESP32Client", token, NULL))
    {
      Serial.println("Connected.");
      
      if(client.subscribe("v1/devices/me/rpc/request/+"))
      {
        Serial.println("successfully subscribed for request.");
      }  // Subscribe to RPC requests
      if(client.subscribe("v1/devices/me/rpc/response/+"))
      {
        Serial.println("successfully subscribed for response.");
      } // Subscribe to RPC responses
     
    }
    else
    {
      Serial.print("failed, status code = ");
      int state = client.state();
      Serial.println(state);
      Serial.println("Try again in 5 seconds");
      /* Wait 5 seconds before retrying */
      delay(5000);
    }
  }
}



unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    Serial.println("Failed to obtain time");
    return 0;
  }
  time(&now);
  return now;
}

void setup() {
  Serial.begin(115200);
  setup_wifi();
  //client.setServer(mqtt_server, mqtt_port);
  //client.setCallback(callback);

  /* set SSL/TLS certificate */
  espClient.setCACert(ca_cert);

  /* configure the MQTT server with IP address and port */
  client.setServer(mqtt_server, 8883);
  client.setCallback(callback);
  
}

void loop() {
  if (!client.connected()) {
    
    serverConnect();
  }
  
  client.loop();
  unsigned long now = millis();


if ((now - lastMsg) > 10000)
   {
     Serial.println("asking knob value ");
     sendRPCRequest(); 
     lastMsg = millis();
   }

  // if ((now - lastMsg) > 10000)
  //  {
  //    Serial.println("Keep Connection Alive ");
  //    publishToThingsBoard();
  //    lastMsg = millis();
  //  }

  
}