#warning **** Included USERMOD_LD2410 ****

#ifndef WLED_ENABLE_MQTT
#error "This user mod requires MQTT to be enabled."
#endif

#pragma once

#include "wled.h"
#include <ld2410.h>

class LD2410Usermod : public Usermod {

  private:

    bool enabled = true;
    bool initDone = false;
    bool sensorFound = false;
    unsigned long lastTime = 0;
    unsigned long last_mqtt_sent = 0;

    int8_t default_uart_rx = 19;
    int8_t default_uart_tx = 18;


    String mqttMovementTopic = F("");
    String mqttStationaryTopic = F("");
    bool mqttInitialized = false;
    bool HomeAssistantDiscovery = true; // Publish Home Assistant Discovery messages


    ld2410 radar;
    bool stationary_detected = false;
    bool last_stationary_state = false;
    bool movement_detected = false;
    bool last_movement_state = false;

    // These config variables have defaults set inside readFromConfig()
    int8_t uart_rx_pin;
    int8_t uart_tx_pin;

    // string that are used multiple time (this will save some flash memory)
    static const char _name[];
    static const char _enabled[];

    void publishMqtt(const char* topic, const char* state, bool retain); // example for publishing MQTT message

    void _mqttInitialize()
    {
      mqttMovementTopic = String(mqttDeviceTopic) + F("/ld2410/movement");
      mqttStationaryTopic = String(mqttDeviceTopic) + F("/ld2410/stationary");
      if (HomeAssistantDiscovery){
        _createMqttSensor(F("Movement"), mqttMovementTopic, F("motion"), F(""));
        _createMqttSensor(F("Stationary"), mqttStationaryTopic, F("occupancy"), F(""));
      } 
    }

    // Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
    void _createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement)
    {
      String t = String(F("homeassistant/binary_sensor/")) + mqttClientID + F("/") + name + F("/config");
      
      StaticJsonDocument<600> doc;
      
      doc[F("name")] = String(serverDescription) + F(" Module");
      doc[F("state_topic")] = topic;
      doc[F("unique_id")] = String(mqttClientID) + name;
      if (unitOfMeasurement != "")
        doc[F("unit_of_measurement")] = unitOfMeasurement;
      if (deviceClass != "")
        doc[F("device_class")] = deviceClass;
      doc[F("expire_after")] = 1800;
      doc[F("payload_off")] = "OFF";
      doc[F("payload_on")] = "ON";

      JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
      device[F("name")] = serverDescription;
      device[F("identifiers")] = "wled-sensor-" + String(mqttClientID);
      device[F("manufacturer")] = F("WLED");
      device[F("model")] = F("FOSS");
      device[F("sw_version")] = versionString;

      String temp;
      serializeJson(doc, temp);
      DEBUG_PRINTLN(t);
      DEBUG_PRINTLN(temp);

      mqtt->publish(t.c_str(), 0, true, temp.c_str());
    }

  public:

    inline bool isEnabled() { return enabled; }

    void setup() {
      Serial1.begin(256000, SERIAL_8N1, uart_rx_pin, uart_tx_pin);
      Serial.print(F("\nLD2410 radar sensor initialising: "));
      if(radar.begin(Serial1)){
        Serial.println(F("OK"));
      } else {
        Serial.println(F("not connected"));
      }
      initDone = true;
    }


    void loop() {
      // NOTE: on very long strips strip.isUpdating() may always return true so update accordingly
      if (!enabled || strip.isUpdating()) return;
      radar.read();
      unsigned long curr_time = millis();
      if(curr_time - lastTime > 1000)  //Try to Report every 1000ms
      {
        lastTime = curr_time;
        sensorFound = radar.isConnected();
        if(!sensorFound) return;
        stationary_detected = radar.presenceDetected();
        if(stationary_detected != last_stationary_state){
          if (WLED_MQTT_CONNECTED){
            publishMqtt("/ld2410/stationary", stationary_detected ? "ON":"OFF", false);
            last_stationary_state = stationary_detected;
          }
        }
        movement_detected = radar.movingTargetDetected();
        if(movement_detected != last_movement_state){
          if (WLED_MQTT_CONNECTED){
            publishMqtt("/ld2410/movement", movement_detected ? "ON":"OFF", false);
            last_movement_state = movement_detected;
          }
        }
        // If there hasn't been any activity, send current state to confirm sensor is alive
        if(curr_time - last_mqtt_sent > 1000*60*5 && WLED_MQTT_CONNECTED){
          publishMqtt("/ld2410/stationary", stationary_detected ? "ON":"OFF", false);
          publishMqtt("/ld2410/movement", movement_detected ? "ON":"OFF", false);
        }
      }
    }


    void addToJsonInfo(JsonObject& root)
    {
      // if "u" object does not exist yet wee need to create it
      JsonObject user = root[F("u")];
      if (user.isNull()) user = root.createNestedObject(F("u"));

      JsonArray ld2410_sta_json = user.createNestedArray(F("LD2410 Stationary"));
      JsonArray ld2410_mov_json = user.createNestedArray(F("LD2410 Movement"));
      if (!enabled){
        ld2410_sta_json.add(F("disabled"));
        ld2410_mov_json.add(F("disabled"));
      } else if(!sensorFound){
        ld2410_sta_json.add(F("LD2410"));
        ld2410_sta_json.add(" Not Found");
      } else {
        ld2410_sta_json.add("Sta ");
        ld2410_sta_json.add(stationary_detected ? "ON":"OFF");
        ld2410_mov_json.add("Mov ");
        ld2410_mov_json.add(movement_detected ? "ON":"OFF");
      }
    }

    void addToConfig(JsonObject& root)
    {
      JsonObject top = root.createNestedObject(FPSTR(_name));
      top[FPSTR(_enabled)] = enabled;
      //save these vars persistently whenever settings are saved
      top["uart_rx_pin"] = default_uart_rx;
      top["uart_tx_pin"] = default_uart_tx;
    }


    bool readFromConfig(JsonObject& root)
    {
      // default settings values could be set here (or below using the 3-argument getJsonValue()) instead of in the class definition or constructor
      // setting them inside readFromConfig() is slightly more robust, handling the rare but plausible use case of single value being missing after boot (e.g. if the cfg.json was manually edited and a value was removed)

      JsonObject top = root[FPSTR(_name)];

      bool configComplete = !top.isNull();
      if (!configComplete)
      {
        DEBUG_PRINT(FPSTR(_name));
        DEBUG_PRINT(F("LD2410"));
        DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
        return false;
      }

      configComplete &= getJsonValue(top["uart_rx_pin"], uart_rx_pin, default_uart_rx);
      configComplete &= getJsonValue(top["uart_tx_pin"], uart_tx_pin, default_uart_tx);

      return configComplete;
    }


#ifndef WLED_DISABLE_MQTT
    /**
     * onMqttConnect() is called when MQTT connection is established
     */
    void onMqttConnect(bool sessionPresent) {
      // do any MQTT related initialisation here
      if(!radar.isConnected()) return;
      publishMqtt("/ld2410/status", "I am alive!", false);
      if (!mqttInitialized)
      {
        _mqttInitialize();
        mqttInitialized = true;
      }
    }
#endif

    uint16_t getId()
    {
      return USERMOD_ID_LD2410;
    }
};


// add more strings here to reduce flash memory usage
const char LD2410Usermod::_name[]    PROGMEM = "LD2410Usermod";
const char LD2410Usermod::_enabled[] PROGMEM = "enabled";


// implementation of non-inline member methods

void LD2410Usermod::publishMqtt(const char* topic, const char* state, bool retain)
{
#ifndef WLED_DISABLE_MQTT
  //Check if MQTT Connected, otherwise it will crash
  if (WLED_MQTT_CONNECTED) {
    last_mqtt_sent = millis();
    char subuf[64];
    strcpy(subuf, mqttDeviceTopic);
    strcat(subuf, topic);
    mqtt->publish(subuf, 0, retain, state);
  }
#endif
}