#pragma once

#include "Arduino.h"
#include "mqtt.h"

enum sensor_e
{
    //PMS sensors
    SP_1P0,
    SP_2P5,
    SP_10P0,
    AE_1P0,
    AE_2P5,
    AE_10P0,
    PPD_0P3,
    PPD_0P5,
    PPD_1P0,
    PPD_2P5,
    PPD_5P0,
    PPD_10P0,
    SCD30_temp,
    SCD30_hum,
    SCD30_co2,
    SGP30_TVOC,
    SGP30_eCO2,
    SGP30_rawH2,
    SGP30_rawEthanol,
    sensor_last
};

class AQSSensor
{
    char _topic[50];
    char _topic_1h[50];
    char _topic_24h[255];
    const String _name;
    const sensor_e _sensor;
    const String _unit;
    uint32_t _value;
    RunningMedian _average1h;
    RunningMedian _average24h;
    bool _publish = false;
    const uint32_t _scaleMin;
    const uint32_t _scaleMax;
    bool _valid;

public:
    AQSSensor(String name, sensor_e sensor, String unit,
              String deviceID, uint8_t avgSamples,
              uint32_t scaleMin, uint32_t scaleMax)
        : _name(name),
          _sensor(sensor),
          _unit(unit),
          _average1h(avgSamples),
          _average24h(avgSamples * 24),
          _scaleMin(scaleMin),
          _scaleMax(scaleMax)
    {
        sprintf(_topic, "Sensors/%s/%s", deviceID.c_str(), name.c_str());
        sprintf(_topic_1h, "Sensors/%s/%s/1h/", deviceID.c_str(), name.c_str());
        sprintf(_topic_24h, "Sensors/%s/%s/24h/", deviceID.c_str(), name.c_str());
        _valid = false;
    }

    void publish(void)
    {
        if (_valid)
        {
            _publish = true;
        }
        else
        {
            Serial.printf("Sensor %s : Not published (invalid)\n", _name.c_str());
        }
    }

    String
    getName(void)
    {
        return _name;
    }

    void published(void)
    {
        _publish = false;
    }

    void publishMQTT(void)
    {
        if (_publish == true)
        {
            publishSingle(_value, _topic);
            publishSingle(_average1h.getMedian(), _topic_1h);
            publishSingle(_average24h.getMedian(), _topic_24h);
            _publish = false;
        }
    }

    virtual void set(uint32_t value)
    {
        if ((value > _scaleMin) && (value < _scaleMax))
        {
            _value = value;
            _average1h.add(_value);
            _average24h.add(_value);
            _valid = true;
        }
        else
        {
            Serial.printf("Sensor %s set(%d): value out of bounds\n", _name.c_str(), _value);
            _valid = false;
        }
    }

    uint32_t value() { return _value; }

    void print(void)
    {
        if (_publish)
        {
            Serial.printf("sensor: report: %s = %d\n", _name.c_str(), _value);
        }
    }

    sensor_e getSensor(void) { return _sensor; }

    String getUnit(void) { return _unit; }

    uint32_t getMin(void) { return _scaleMin; }
    uint32_t getMax(void) { return _scaleMax; }
};

void addSensorToList(AQSSensor *sensor);
void reportToSerial(void);
AQSSensor *getSensor(sensor_e sensor);
uint32_t getSensorValue(sensor_e sensor);

void initSensor(void);
void handleSensor(void);