#include <Arduino.h>
#include <ArduinoOTA.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include "SdsDustSensor.h"

#define WIFI_SSID "wf-home"
#define WIFI_PASSWORD "0ndthnrf"
#define MQTT_SERV "192.168.1.250"

#define HOSTNAME "ESP_Kor"

#define LED_WF (D0)
#define LED_MQ (D3)
#define LED_WRK (D4)

int rxPin = D1;
int txPin = D2;
SdsDustSensor sds(rxPin, txPin);

AsyncMqttClient mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
Ticker wifiReconnectTimer;

void connectToWifi();
void connectToMqtt();
void onWifiConnect(const WiFiEventStationModeGotIP& event);
void onWifiDisconnect(const WiFiEventStationModeDisconnected& event);
void onMqttConnect(bool sessionPresent);
void onMqttDisconnect(AsyncMqttClientDisconnectReason reason);
void onMqttSubscribe(uint16_t packetId, uint8_t qos);
void onMqttUnsubscribe(uint16_t packetId);
void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total);
void onMqttPublish(uint16_t packetId);

unsigned long cRun;
int cSec = 0;

void setup()
{
  Serial.begin(9600);
  WiFi.mode(WIFI_STA);
  WiFi.hostname(HOSTNAME);
	ArduinoOTA.onStart([]() {
		Serial.println("ArduinoOTA start");
	});
	ArduinoOTA.onEnd([]() {
		Serial.println("\nArduinoOTA end");
	});
	ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
		Serial.printf("OTA Progress: %u%%\r", (progress / (total / 100)));
	});
	ArduinoOTA.onError([](ota_error_t error) {
		Serial.printf("Error[%u]: ", error);
		if (error == OTA_AUTH_ERROR) {
			Serial.println("Auth Failed");
		} else if (error == OTA_BEGIN_ERROR) {
			Serial.println("Begin Failed");
		} else if (error == OTA_CONNECT_ERROR) {
			Serial.println("Connect Failed");
		} else if (error == OTA_RECEIVE_ERROR) {
			Serial.println("Receive Failed");
		} else if (error == OTA_END_ERROR) {
			Serial.println("End Failed");
		}
	});
	ArduinoOTA.begin();

	wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
	wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);

	mqttClient.onConnect(onMqttConnect);
	mqttClient.onDisconnect(onMqttDisconnect);
	mqttClient.onSubscribe(onMqttSubscribe);
	mqttClient.onUnsubscribe(onMqttUnsubscribe);
	mqttClient.onMessage(onMqttMessage);
	mqttClient.onPublish(onMqttPublish);
	mqttClient.setServer(MQTT_SERV, 1883);

  sds.begin();

  // Serial.println(sds.queryFirmwareVersion().toString()); // prints firmware version
  // Serial.println(sds.setActiveReportingMode().toString()); // ensures sensor is in 'active' reporting mode
  // Serial.println(sds.setCustomWorkingPeriod(3).toString()); // sensor sends data every 3 minutes
  sds.setActiveReportingMode();
  sds.setCustomWorkingPeriod(1);

  pinMode(LED_WF, OUTPUT);
  pinMode(LED_MQ, OUTPUT);
  pinMode(LED_WRK, OUTPUT);
  digitalWrite(LED_WF, HIGH);
  digitalWrite(LED_MQ, HIGH);

  cRun = millis();
}

void loop()
{
	//static bool lwork = false;
  static unsigned long stled = millis();
	ArduinoOTA.handle();
  if(cRun + 999 < millis()){
    cRun = millis();
    PmResult pm = sds.readPm();
    if((stled + 300) < millis()) digitalWrite(LED_WRK, LOW);
    //lwork = !lwork;
    cSec++;
    if (pm.isOk()) {
      if(mqttClient.connected()){
        digitalWrite(LED_WRK, HIGH);
        stled = millis();
        char v[6];
        sprintf(v, "%.1f", pm.pm25);
        mqttClient.publish("/home/kor/pm25", 1, false, v);
        sprintf(v, "%.1f", pm.pm10);
        mqttClient.publish("/home/kor/pm10", 1, false, v);
      }
      Serial.print(cRun); Serial.print("\t");
      Serial.print("PM2.5 = ");
      Serial.print(pm.pm25);
      Serial.print(", PM10 = ");
      Serial.println(pm.pm10);

      cSec = 0;
    }
  }
}

void connectToWifi() {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}

void connectToMqtt() {
  Serial.println("Connecting to MQTT...");
  mqttClient.connect();
}

void onWifiConnect(const WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
  connectToMqtt();
  digitalWrite(LED_WF, LOW);
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected& event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
  wifiReconnectTimer.once(2, connectToWifi);
  digitalWrite(LED_WF, HIGH);
}

void onMqttConnect(bool sessionPresent) {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present: ");
  Serial.println(sessionPresent);
  digitalWrite(LED_MQ, LOW);
}

void onMqttDisconnect(AsyncMqttClientDisconnectReason reason) {
  //Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected()) {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
  digitalWrite(LED_MQ, HIGH);
}

void onMqttSubscribe(uint16_t packetId, uint8_t qos) {
  Serial.println("Subscribe acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
  Serial.print("  qos: ");
  Serial.println(qos);
}

void onMqttUnsubscribe(uint16_t packetId) {
  Serial.println("Unsubscribe acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}

void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) {
}

void onMqttPublish(uint16_t packetId) {
  Serial.println("Publish acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}