#define BLYNK_TEMPLATE_ID "TMPL6vYtidvW5"
#define BLYNK_TEMPLATE_NAME "IoT enable energy consumption"
#define BLYNK_AUTH_TOKEN "3MhU2RWW1wTnrPrZH4eVuLJqfCpeja9K"
#define BLYNK_PRINT Serial

#include "EmonLib.h"
//#include <Filters.h>
#include <Wire.h>
#include <BH1750.h>
#include <DHT.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#include "ThingSpeak.h"

EnergyMonitor emon;
#define vCalibration 95.8 //106
#define currCalibration 0.52

char auth[] = BLYNK_AUTH_TOKEN;
char ssid[] = "Wokwi-GUEST";
char pass[] = "";

const int myChannelNumber = 2203057;
const char* myApiKey = "HY20IU09Y79R7G19";
const char* server = "api.thingspeak.com";

float kWh = 0;
unsigned long lastmillis = millis();

BlynkTimer timer;

// Relay pin definitions
#define RELAYSYSTEM_PIN     13
#define RELAYPIR_PIN        25
#define RELAYAUTO_PIN       33
#define RELAYSLEEP_PIN      32
#define RELAYMANUAL_PIN     26
#define RELAYFAN_PIN        12
#define RELAYSOCKET_PIN     14
#define RELAYLIGHT_PIN      27
#define MOTION_SENSOR_PIN    4
#define DHTPIN              15
#define DHTTYPE DHT22

// Global variables
int LDR = 34;
int RELAYSYSTEM_STATE = 0;
int RELAYPIR_STATE = 0;
int RELAYAUTO_STATE = 0;
int RELAYSLEEP_STATE  = 0;
int RELAYMANUAL_STATE  = 0;
int RELAYFAN_STATE = 0;
int FAN_STATE = 0;
int LIGHT_STATE = 0;
int SOCKET_STATE = 0;
int RELAYSOCKET_STATE  = 0;
int RELAYLIGHT_STATE  = 0;
int pir_state = 0;
int nilaiLDR = 0;

float occupancy;
float lux;
float temperature;
int brightness;

BH1750 lightMeter;
DHT dht(DHTPIN, DHTTYPE);
WiFiClient client;

// Blynk virtual pin definitions
#define system_switch       V0
#define sleepmode_switch    V1
#define auto_switch         V10
#define manual_switch       V11
#define fan_switch          V12
#define light_switch        V13
#define socket_switch       V14
#define mode_switch         V16

#define lux_display         V2
#define temp_display        V3
#define occupancy_display   V15
#define fanP_display        V7
#define lightP_display      V8
#define socketP_display     V9

#define fan_state           V4
#define socket_state        V6
#define light_state         V5

#define occupancy_data      V15

BLYNK_CONNECTED() {
  // Sync Blynk virtual pins on connection
  Blynk.syncVirtual(system_switch);
  Blynk.syncVirtual(sleepmode_switch);
  Blynk.syncVirtual(auto_switch);
  Blynk.syncVirtual(manual_switch);
  Blynk.syncVirtual(fan_switch);
  Blynk.syncVirtual(light_switch);
  Blynk.syncVirtual(socket_switch);
  Blynk.syncVirtual(mode_switch);

  Blynk.syncVirtual(lux_display);
  Blynk.syncVirtual(temp_display);
  Blynk.syncVirtual(occupancy_display);
  Blynk.syncVirtual(fanP_display);
  Blynk.syncVirtual(lightP_display);
  Blynk.syncVirtual(socketP_display);

  Blynk.syncVirtual(fan_state);
  Blynk.syncVirtual(socket_state);
  Blynk.syncVirtual(light_state);

  Blynk.syncVirtual(occupancy_data);
}

BLYNK_WRITE (mode_switch) {
  if (occupancy > 0) {
    switch (param.asInt()) {
      case 0: {
          // Item 0 - Turn off the system
          RELAYSYSTEM_STATE = LOW;
          occupancy = 0;
          digitalWrite(RELAYSYSTEM_PIN, RELAYSYSTEM_STATE);
          Blynk.virtualWrite(occupancy_data, 0);
          RELAYSLEEP_STATE = LOW;
          RELAYAUTO_STATE = LOW;
          RELAYLIGHT_STATE = LOW;
          RELAYFAN_STATE = LOW;
          RELAYSOCKET_STATE = LOW;
          RELAYPIR_STATE = LOW;
          SOCKET_STATE = LOW;
          FAN_STATE = LOW;
          LIGHT_STATE = LOW;
          RELAYMANUAL_STATE = LOW;
          digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
          digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
          digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
          digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
          digitalWrite(RELAYLIGHT_PIN, RELAYLIGHT_STATE);
          digitalWrite(RELAYSOCKET_PIN, RELAYSOCKET_STATE);
          digitalWrite(RELAYPIR_PIN, RELAYSOCKET_STATE);
          Blynk.virtualWrite(auto_switch, RELAYSLEEP_STATE);
          Blynk.virtualWrite(manual_switch, RELAYSLEEP_STATE);
          Blynk.virtualWrite(sleepmode_switch, RELAYSLEEP_STATE);
          Blynk.virtualWrite(mode_switch, 0);
          Blynk.virtualWrite(fan_switch, RELAYSLEEP_STATE);
          Blynk.virtualWrite(light_switch, RELAYSLEEP_STATE);
          Blynk.virtualWrite(socket_switch, RELAYSLEEP_STATE);
          break;
        }
      case 1: {
          // Item 1 - Manual mode
          RELAYSYSTEM_STATE = HIGH;
          digitalWrite(RELAYSYSTEM_PIN, RELAYSYSTEM_STATE);
          RELAYMANUAL_STATE = HIGH;
          RELAYLIGHT_STATE = LOW;
          RELAYFAN_STATE = LOW;
          FAN_STATE = LOW;
          LIGHT_STATE = LOW;
          digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
          digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
          digitalWrite(RELAYLIGHT_PIN, RELAYLIGHT_STATE);
          Blynk.virtualWrite(fan_switch, RELAYFAN_STATE);
          Blynk.virtualWrite(light_switch, RELAYLIGHT_STATE);
          RELAYSLEEP_STATE = LOW;
          RELAYAUTO_STATE = LOW;
          digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
          digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
          Blynk.virtualWrite(auto_switch, RELAYAUTO_STATE);
          Blynk.virtualWrite(sleepmode_switch, RELAYSLEEP_STATE);
          break;
        }
      case 2: {
          // Item 2 - Auto mode
          RELAYSYSTEM_STATE = HIGH;
          digitalWrite(RELAYSYSTEM_PIN, RELAYSYSTEM_STATE);
          RELAYAUTO_STATE = HIGH;
          Blynk.virtualWrite(fan_switch, LOW);
          Blynk.virtualWrite(light_switch, LOW);
          RELAYSLEEP_STATE = LOW;
          RELAYMANUAL_STATE = LOW;
          digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
          digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
          Blynk.virtualWrite(manual_switch, RELAYMANUAL_STATE);
          Blynk.virtualWrite(sleepmode_switch, RELAYSLEEP_STATE);
          digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
          break;
        }
      case 3: {
          // Item 3 - Sleep mode
          RELAYSYSTEM_STATE = HIGH;
          digitalWrite(RELAYSYSTEM_PIN, RELAYSYSTEM_STATE);
          RELAYSLEEP_STATE = HIGH;
          Blynk.virtualWrite(fan_switch, LOW);
          Blynk.virtualWrite(light_switch, LOW);
          RELAYMANUAL_STATE = LOW;
          RELAYAUTO_STATE = LOW;
          digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
          digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
          Blynk.virtualWrite(auto_switch, RELAYAUTO_STATE);
          Blynk.virtualWrite(manual_switch, RELAYMANUAL_STATE);
          digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
          break;
        }
    }
  }
}

BLYNK_WRITE(occupancy_data) {
  occupancy = param.asFloat();
  if (RELAYSYSTEM_STATE == HIGH) {
    if (occupancy == 0) {
      RELAYSLEEP_STATE = LOW;
      RELAYAUTO_STATE = LOW;
      RELAYLIGHT_STATE = LOW;
      RELAYFAN_STATE = LOW;
      RELAYSOCKET_STATE = LOW;
      RELAYPIR_STATE = LOW;
      SOCKET_STATE = LOW;
      FAN_STATE = LOW;
      LIGHT_STATE = LOW;
      RELAYMANUAL_STATE = LOW;
      digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
      digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
      digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
      digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
      digitalWrite(RELAYLIGHT_PIN, RELAYLIGHT_STATE);
      digitalWrite(RELAYSOCKET_PIN, RELAYSOCKET_STATE);
      digitalWrite(RELAYPIR_PIN, RELAYSOCKET_STATE);
      Blynk.virtualWrite(auto_switch, RELAYSLEEP_STATE);
      Blynk.virtualWrite(manual_switch, RELAYSLEEP_STATE);
      Blynk.virtualWrite(sleepmode_switch, RELAYSLEEP_STATE);
      Blynk.virtualWrite(mode_switch, 0);
      Blynk.virtualWrite(fan_switch, RELAYSLEEP_STATE);
      Blynk.virtualWrite(light_switch, RELAYSLEEP_STATE);
      Blynk.virtualWrite(socket_switch, RELAYSLEEP_STATE);
    }
  }
}

BLYNK_WRITE(fan_switch) {
  FAN_STATE = param.asInt();
  if (FAN_STATE == LOW) {
    digitalWrite(RELAYFAN_PIN, FAN_STATE);
  }
}

BLYNK_WRITE(light_switch) {
  LIGHT_STATE = param.asInt();
}

BLYNK_WRITE(socket_switch) {
  SOCKET_STATE = param.asInt();
}

void myTimerEvent() {
  // Energy monitoring code
  emon.calcVI(20, 2000);
  Serial.print("Vrms: ");
  Serial.print(emon.Vrms, 2);
  Serial.print("V");
  //Blynk.virtualWrite(V6, emon.Vrms);
  Serial.print("\tIrms: ");
  Serial.print(emon.Irms, 4);
  Serial.print("A");
  //Blynk.virtualWrite(V7, emon.Irms);
  Serial.print("\tPower: ");
  Serial.print(emon.apparentPower, 4);
  Serial.print("W");
  //Blynk.virtualWrite(V8, emon.apparentPower);
  Serial.print("\tkWh: ");
  kWh = kWh + emon.apparentPower * (millis() - lastmillis) / 3600000000.0;
  Serial.print(kWh, 4);
  Serial.println("kWh");
  lastmillis = millis();
  Blynk.virtualWrite(lightP_display, kWh);
}

void readSensor() {
  // Sensor reading code
  nilaiLDR = analogRead(LDR);
  //lux = lightMeter.readLightLevel();
  //brightness = map( nilaiLDR, 0, 65535, 0, 255);
  temperature = dht.readTemperature();
}

void sendSensor() {
  // Send sensor data to Blynk
  readSensor();
  //Blynk.virtualWrite(lux_display, lux);
  Blynk.virtualWrite(lux_display, nilaiLDR);
  Blynk.virtualWrite(temp_display, temperature);
}

void setup() {
  // Setup code
  Serial.begin(115200);
  pinMode(RELAYSYSTEM_PIN, OUTPUT);
  pinMode(RELAYPIR_PIN, OUTPUT);
  pinMode(RELAYAUTO_PIN, OUTPUT);
  pinMode(RELAYSLEEP_PIN, OUTPUT);
  pinMode(RELAYMANUAL_PIN, OUTPUT);
  pinMode(RELAYFAN_PIN, OUTPUT);
  pinMode(RELAYSOCKET_PIN, OUTPUT);
  pinMode(RELAYLIGHT_PIN, OUTPUT);
  pinMode(MOTION_SENSOR_PIN, INPUT);

  Blynk.begin(auth, ssid, pass);
  ThingSpeak.begin(client);

  Wire.begin();
  lightMeter.begin();
  lightMeter.setMTreg(69); // Set the measurement time to 120ms
  Serial.println(F("BH1750 Test begin"));
  dht.begin();

  timer.setInterval(100L, sendSensor);
  timer.setInterval(100L, myTimerEvent);
}

void loop() {
  // Blynk and ThingSpeak update loop
  Blynk.run();
  timer.run();
  ThingSpeak.setField(1, temperature);
  ThingSpeak.setField(2, nilaiLDR);
  ThingSpeak.setField(3, occupancy);
  ThingSpeak.setField(4, kWh);
  //ThingSpeak.setField(5,data.temperature);
  //ThingSpeak.setField(6,data.humidity);
  ThingSpeak.setField(5, RELAYMANUAL_STATE);
  ThingSpeak.setField(6, RELAYAUTO_STATE);

  // PIR Motion control
  pir_state = digitalRead(MOTION_SENSOR_PIN);
  if (occupancy > 0) {
    if (RELAYSYSTEM_STATE == HIGH) {
      if (occupancy > 0 && SOCKET_STATE == HIGH) {
        RELAYSOCKET_STATE = HIGH;
      }
      else {
        RELAYSOCKET_STATE = LOW;
      }
      digitalWrite(RELAYSOCKET_PIN, RELAYSOCKET_STATE);

      if (RELAYSLEEP_STATE == HIGH) {
        digitalWrite(RELAYLIGHT_PIN, LOW);
        if (temperature > 27 && occupancy > 0) {
          RELAYFAN_STATE = HIGH;
        }
        else {
          RELAYFAN_STATE = LOW;
        }
        digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
      }
      else {
        digitalWrite(RELAYSLEEP_PIN, RELAYSLEEP_STATE);
      }

      if (RELAYAUTO_STATE == HIGH) {
        digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);

        if (pir_state == HIGH) {
          RELAYPIR_STATE = HIGH;
        }
        else {
          RELAYPIR_STATE = LOW;
        }
        digitalWrite(RELAYPIR_PIN, RELAYPIR_STATE);

        if (nilaiLDR > 2404 && occupancy > 0 && RELAYPIR_STATE == HIGH) {
          RELAYLIGHT_STATE = HIGH;
        }
        else {
          RELAYLIGHT_STATE = LOW;
        }
        digitalWrite(RELAYLIGHT_PIN, RELAYLIGHT_STATE );

        if (temperature > 27 && occupancy > 0 && RELAYPIR_STATE == HIGH ) {
          RELAYFAN_STATE = HIGH;
        }
        else {
          RELAYFAN_STATE = LOW;
        }
        digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
      }
      else {
        RELAYPIR_STATE = LOW;
        digitalWrite(RELAYPIR_PIN, RELAYAUTO_STATE);
        digitalWrite(RELAYAUTO_PIN, RELAYAUTO_STATE);
      }

      if (RELAYMANUAL_STATE == HIGH) {
        RELAYMANUAL_STATE = HIGH;
        digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
        if (nilaiLDR > 2404 && occupancy > 0 && LIGHT_STATE == HIGH) {
          RELAYLIGHT_STATE = HIGH;
        }
        else {
          RELAYLIGHT_STATE = LOW;
        }
        digitalWrite(RELAYLIGHT_PIN, RELAYLIGHT_STATE);

        if (temperature > 27 && occupancy > 0 && FAN_STATE == HIGH) {
          RELAYFAN_STATE = HIGH;
        }
        else {
          RELAYFAN_STATE = LOW;
        }
        digitalWrite(RELAYFAN_PIN, RELAYFAN_STATE);
      }
      else {
        digitalWrite(RELAYSOCKET_PIN, RELAYSOCKET_STATE);
        digitalWrite(RELAYMANUAL_PIN, RELAYMANUAL_STATE);
      }
    }
    else {
      digitalWrite(RELAYSYSTEM_PIN, RELAYSYSTEM_STATE);
      Blynk.virtualWrite(system_switch, RELAYSYSTEM_STATE);

    }
    int x = ThingSpeak.writeFields(myChannelNumber, myApiKey);

    if (x == 200) {
      Serial.println("Data pushed successfully");
    }
    else {
      Serial.println("Push error: " + String(x));
    }
    Serial.println("---");
  }
  else {
    Blynk.virtualWrite(system_switch, LOW);
    Blynk.virtualWrite(mode_switch, 0);
    digitalWrite(RELAYSYSTEM_PIN, LOW);
  }
}