#include <AnalogIoT.hpp>

AnalogIoT::AnalogIoT() {
    for (uint8_t i = 0; i < 8; i++) {
        adc_publish_enabled[i] = false;
        adc_conversion_interval[i] = 1000;
    }
}

AnalogIoT::~AnalogIoT() {
}
bool AnalogIoT::begin(uint8_t card_id, ExpansionCard *card, PubSubClient *mqtt, char *base_topic) {
    this->mqtt = mqtt;
    this->base_topic = base_topic;
    this->card = (AnalogCard*)card;
    this-> card_id = card_id;
    this->dac_set_state_length = strlen(DAC_SET_STATE_TOPIC);
    this->dac_set_value_length = strlen(DAC_SET_VALUE_TOPIC);
    this->dac_state_length = strlen(DAC_STATE_TOPIC);
    this->dac_value_length = strlen(DAC_VALUE_TOPIC);
    this->request_state_length = strlen(REQUEST_STATE_TOPIC);
    this->dac_publish_enable_length = strlen(DAC_PUBLISH_ENABLE_TOPIC);
    // Register callbacks
    auto bindedCallback =  std::bind(&AnalogIoT::handleDACChange, this, std::placeholders::_1, std::placeholders::_2);
    this->card->registerDACChangeCallback(bindedCallback);
    return true;
}
void AnalogIoT::handleMqttMessage(char *topic, char *payload){ 
    uint8_t topic_length = strlen(topic);
    if(this-> processDACSetStateMessage(topic, payload, topic_length)) return;
    if(this-> processDACSetValueMessage(topic, payload, topic_length)) return;
    if(this-> processRequestStateMessage(topic, payload, topic_length)) return;
    if(this-> processADCSetConversionIntervalMessage(topic, payload, topic_length)) return;
    if(this-> processADCSetConversionEnabledMessage(topic, payload, topic_length)) return;
}
void AnalogIoT::publishADCs() {
    for (uint8_t i = 0; i < 8; i++) {
        this->publishADC(i);
    }
}
void AnalogIoT::publishADC(uint8_t pin) {
    if (this->adc_publish_enabled[pin]) {
        uint16_t value = this->card->analogRead(pin);
        char *topic = new char[15];
        sprintf(topic, "adc/%02d/value", pin);
        char *payload = new char[10];
        sprintf(payload, "%d", value);
        this->publishRelative(topic, payload);
        delete[] topic;
        delete[] payload;
        // Call all callbacks
        for (int i = 0; i < this->adc_conversion_callbacks.size(); i++) {
            this->adc_conversion_callbacks[i](pin, value);
        }
    }
}
void AnalogIoT::setADCsPublishInterval(uint32_t interval) {
    for (uint8_t i = 0; i < 8; i++) {
        adc_conversion_interval[i] = interval;
    }   
}
void AnalogIoT::setADCsPublishEnabled(bool enabled) {
    for (uint8_t i = 0; i < 8; i++) {
        adc_publish_enabled[i] = enabled;
    }
}
void AnalogIoT::registerADCConversionCallback(std::function<void(uint8_t, uint16_t)> callback) {
    this->adc_conversion_callbacks.push_back(callback);
}
// void AnalogIoT::deregisterADCConversionCallback(std::function<void(uint8_t, uint16_t)> callback) {
//     for (int i = 0; i < this->adc_conversion_callbacks.size(); i++) {
//         if (this->adc_conversion_callbacks[i].target<void(uint8_t, uint16_t)>() == callback.target<void(uint8_t, uint16_t)>()) {
//             this->adc_conversion_callbacks.erase(this->adc_conversion_callbacks.begin() + i);
//             break;
//         }
//     }
// }
void AnalogIoT::setADCConversionInterval(uint8_t pin, uint16_t interval) {
    adc_conversion_interval[pin] = interval;
}
void AnalogIoT::setADCConversionEnabled(uint8_t pin, bool enabled) {
    adc_publish_enabled[pin] = enabled;
}
bool AnalogIoT::processADCSetConversionIntervalMessage(char *topic, char *payload, uint8_t topic_length) {
    // TODO: Process payload matching the criteria
    // Topic: adc/<%02d>/set/conversion_interval
    // The first 4 characters are "adc/"
    // The length of the topic must be 30 characters
    // The last 24 characters must be "/set/conversion_interval"
    // After all these conditions are met, the topic is valid
    // Extract the pin number from the topic
    if (topic_length != 30) {
        return false;
    }
    if (strncmp(topic, "adc/", 4)) {
        return false;
    }
    if (strncmp(topic + 26, "/set/conversion_interval", 24)) {
        return false;
    }
    uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
    // Extract the payload
    uint16_t interval = atoi(payload);
    // Set the interval
    this->setADCConversionInterval(pin, interval);
    return true;
}
bool AnalogIoT::processADCSetConversionEnabledMessage(char *topic, char *payload, uint8_t topic_length) {
    // Topic: adc/<%02d>/set/conversion_enabled
    // The first 4 characters are "adc/"
    // The length of the topic must be 29 characters
    // The last 23 characters must be ""/set/conversion_enabled
    // After all these conditions are met, the topic is valid
    // Extract the pin number from the topic
    if (topic_length != 29) {
        return false;
    }
    if (strncmp(topic, "adc/", 4)) {
        return false;
    }
    if (strncmp(topic + 25, "/set/conversion_enabled", 23)) {
        return false;
    }
    uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0'); 
    // Extract the payload
    bool enabled = atoi(payload);
    // Set conversion enabled
    this->setADCConversionEnabled(pin, enabled);
    return true;
}
bool AnalogIoT::processDACSetStateMessage(char *topic, char *payload, uint8_t topic_length) {
    // Topic: dac/<%02d>/set/state
    // The first 4 characters are "dac/"
    // The length of the topic must be 16 characters
    // The last 10 characters must be "/set/state"
    // After all these conditions are met, the topic is valid
    // Extract the pin number from the topic
    if (topic_length != 16) {
        return false;
    }
    if (strncmp(topic, "dac/", 4)) {
        return false;
    }
    if (strncmp(topic + 12, "/set/state", 10)) {
        return false;
    }
    uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
    // Extract the payload
    bool state = atoi(payload);
    // Set the state
    this->card->setDACState(pin, state);
    return true;
}
bool AnalogIoT::processDACSetValueMessage(char *topic, char *payload, uint8_t topic_length) {
    // Topic: dac/<%02d>/set/value
    // The first 4 characters are "dac/"
    // The length of the topic must be 16 characters
    // The last 10 characters must be "/set/value"
    // After all these conditions are met, the topic is valid
    // Extract the pin number from the topic
    if (topic_length != 16) {
        return false;
    }
    if (strncmp(topic, "dac/", 4)) {
        return false;
    }
    if (strncmp(topic + 12, "/set/value", 10)) {
        return false;
    }
    uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
    // Extract the payload
    uint16_t value = atoi(payload);
    // Set the value
    this->card->setDACValue(pin, value);
    return true;
}
bool AnalogIoT::processRequestStateMessage(char *topic, char *payload, uint8_t topic_length) {
    // Topic: requeststate
    // The length of the topic must be 12 characters
    // After all these conditions are met, the topic is valid
    if (topic_length != 12) {
        return false;
    }
    if (strncmp(topic, REQUEST_STATE_TOPIC, 12)) {
        return false;
    }
    // Publish the state of all DACs
    this->publishDACs();
    // Publish the state of all ADCs
    this->publishADCs();
    return false;
}
void AnalogIoT::subscribe() {
    // There are 4 DACs and 8 ADCs
    // DACs: dac/<%02d>/set/state, dac/<%02d>/set/value, dac/publish_enable
    // ADCs: adc/<%02d>/set/conversion_interval, adc/<%02d>/set/conversion_enabled

    // Subscribe to all set state topics
    char topic[20];
    for (uint8_t i = 0; i < 4; i++) {
        sprintf(topic, "dac/%02d/set/state", i);
        this->subscribeRelative(topic);
    }
    // Subscribe to all set value topics
    for (uint8_t i = 0; i < 4; i++) {
        sprintf(topic, "dac/%02d/set/value", i);
        this->subscribeRelative(topic);
    }
    // Subscribe to all set conversion interval topics
    for (uint8_t i = 0; i < 8; i++) {
        sprintf(topic, "adc/%02d/set/conversion_interval", i);
        this->subscribeRelative(topic);
    }
    // Subscribe to all set conversion enabled topics
    for (uint8_t i = 0; i < 8; i++) {
        sprintf(topic, "adc/%02d/set/conversion_enabled", i);
        this->subscribeRelative(topic);
    }
    // Subscribe to publish enable topic
    this->subscribeRelative("dac/publish_enable");
}
void AnalogIoT::loop() {
    // Iterate over all ADCs and publish if enabled and interval has passed
    uint32_t now = millis();
    for (uint8_t i = 0; i < 8; i++) {
        if (this->adc_publish_enabled[i] && now - this->last_adc_publish > this->adc_conversion_interval[i]) {
            this->publishADC(i);
            this->last_adc_publish = now;
        }
    }
}
void AnalogIoT::publishReport() {
    publishADCs();
    publishDACs();
}

uint8_t AnalogIoT::getType() {
    return CARD_TYPE_ANALOG;
}
void AnalogIoT::publishDACs() {
    for (uint8_t i = 0; i < 4; i++) {
        this->publishDAC(i);
    }
}
void AnalogIoT::publishDAC(uint8_t pin) {
    this->publishDACState(pin);
    this->publishDACValue(pin);
}
void AnalogIoT::publishDACState(uint8_t pin) {
    char *topic = new char[15];
    sprintf(topic, "dac/%02d/state", pin);
    char *payload = new char[2];
    sprintf(payload, "%d", this->card->getDACState(pin));
    this->publishRelative(topic, payload);
    delete[] topic;
    delete[] payload;
}
void AnalogIoT::publishDACValue(uint8_t pin) {
    char *topic = new char[15];
    sprintf(topic, "dac/%02d/value", pin);
    char *payload = new char[5];
    sprintf(payload, "%d", this->card->getDACValue(pin));
    this->publishRelative(topic, payload);
    delete[] topic;
    delete[] payload;
}