#include "ADCconf.h"

bool IRAM_ATTR ADC_BME::adc_dma_callback(adc_continuous_handle_t handle, const adc_continuous_evt_data_t *edata, void *user_data){
    ADC_BME* adc =static_cast<ADC_BME*>(user_data);
    adc->dma_data_ready = true;
    return false;
}

void ADC_BME::config(const uint32_t muestras_bloque, adc_channel_t channel, const uint32_t hz_adc, uint8_t* dma_buffer){
    _FRAME_SIZE=muestras_bloque*4;
    _POOL_SIZE=_FRAME_SIZE*4;
    _channel=channel;
    _HZ_ADC=hz_adc;
    _dma_buffer=dma_buffer;
}

void ADC_BME::setup(){
    adc_continuous_handle_cfg_t ADC_config = {
        .max_store_buf_size = _POOL_SIZE,
        .conv_frame_size = _FRAME_SIZE,
    };
    ESP_ERROR_CHECK(adc_continuous_new_handle(&ADC_config, &handle_ADC));

    adc_digi_pattern_config_t channel_config = {0};
    channel_config.channel = _channel;
    channel_config.atten = ADC_ATTEN_DB_12;
    channel_config.bit_width = ADC_BITWIDTH_12;
    channel_config.unit = ADC_UNIT_1;

    adc_continuous_config_t adc_config = {
          .pattern_num = 1,
          .adc_pattern = &channel_config,
          .sample_freq_hz = _HZ_ADC,
          .conv_mode = ADC_CONV_SINGLE_UNIT_1,
    };

    ESP_ERROR_CHECK(adc_continuous_config(handle_ADC, &adc_config));

    adc_continuous_evt_cbs_t cb_config = {
        .on_conv_done = adc_dma_callback,
        .on_pool_ovf = NULL
    };

    ESP_ERROR_CHECK(adc_continuous_register_event_callbacks(handle_ADC, &cb_config, this));
    ESP_ERROR_CHECK(adc_continuous_start(handle_ADC));
    Serial.println("DMA Iniciado con sistema de bandera.");
}

uint32_t ADC_BME::read(uint16_t* samples_buffer) {

    if (!dma_data_ready) {
        return 0;
    }

    dma_data_ready = false;
    uint32_t ret_num = 0;

    // Leer datos DMA
    esp_err_t ret = adc_continuous_read(handle_ADC,_dma_buffer,_FRAME_SIZE,&ret_num,0);

    if (ret != ESP_OK)
        return 0;

    // Buffer temporal parseado
    adc_continuous_data_t parsed_data[_FRAME_SIZE/4];

    uint32_t parsed_count = 0;

    // Parsear datos
    esp_err_t parse_ret =
        adc_continuous_parse_data(
            handle_ADC,
            _dma_buffer,
            ret_num,
            parsed_data,
            &parsed_count
        );

    if (parse_ret != ESP_OK) {
        return 0;
    }

    uint32_t valid_samples = 0;
    // Copiar muestras limpias
    for (uint32_t i = 0; i < parsed_count; i++) {
        if (!parsed_data[i].valid)
            continue;

        samples_buffer[valid_samples] = parsed_data[i].raw_data;
        valid_samples++;
    }

    return valid_samples;
}