#pragma once
// using external voltage reference

#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/optional.h"
#include "ads131m08_defs.h"
#include "frame.h"
#include <string>
#include <charconv>
#include <format>

//#include "esphome/core/component.h"
//#include <esphome/core/hal.h>
#include "esphome/components/spi/spi.h"
#include "esphome/components/sensor/sensor.h"
//
//#include <vector>
//#include <esphome/core/gpio.h>
//#include <freertos/FreeRTOS.h>
//#include <freertos/semphr.h>
//#include <atomic>

namespace esphome {
namespace ads131m08 {

static const int MAX_CHANNELS = 11; // for debugging
static const int ADC_CHANNELS = 8;
static const int SAMPLE_TIME_SENSOR = 8; // for debugging
static const int MAX_SAMPLES_SENSOR = 9; // for debugging
static const int CRC_ERRORS_SENSOR = 10; // for debugging

typedef union {

    int32_t i;
    float f;
    uint16_t u[2];
    uint8_t b[4];
} flex32_t;


/* Adc Structure. Ch can be read as int32 or float*/
struct AdcOutput
{
  uint16_t status;
  flex32_t ch[ADC_CHANNELS];
};

//#define SET_IRAM IRAM_ATTR
#define SET_IRAM

typedef std::vector<uint8_t> spiframe;
typedef uint_str<uint16_t>::Ty_string uint16_str; // we want to use the stack to pass small arrays

class ADS131M08Hub : public Component, public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_8MHZ> 
{
  friend class ads131m08_select;
 public:
  enum crc_pos: uint8_t {
      crc_after_frame,
      crc_after_firstword,
  };
  // register config values used
  static constexpr uint16_t reg_clock_cfg = MASK_CLOCK_EXTREF_EN | OSR_1024 | PM_HIGH_RESOLUTION;
  static constexpr uint16_t reg_clock_allch_on = MASK_CLOCK_ALLCH | reg_clock_cfg;
  static constexpr uint16_t reg_clock_allch_off = ~MASK_CLOCK_ALLCH & reg_clock_cfg;
  static constexpr uint16_t reg_mode_cfg16 = WLENGTH_16_BITS | DRDY_FMT_PULSE | TIMEOUT_ENABLED;
  static constexpr uint16_t reg_mode_cfg24 = WLENGTH_24_BITS | DRDY_FMT_PULSE | TIMEOUT_ENABLED;
  static constexpr uint16_t reg_mode_cfg32 = WLENGTH_32_BITS_MSB_SIGN_EXTEND | DRDY_FMT_PULSE | TIMEOUT_ENABLED; 
  // masks for the above 
  static constexpr uint16_t reg_clock_cfg_mask = MASK_CLOCK_EXTREF_EN | MASK_CLOCK_OSR | MASK_CLOCK_PWR;
  static constexpr uint16_t reg_clock_allch_mask = MASK_CLOCK_ALLCH_OFF | reg_clock_cfg_mask;
  static constexpr uint16_t reg_mode_cfg_mask = MASK_MODE_WLENGTH | MASK_MODE_DRDY_FMT | MASK_MODE_TIMEOUT;
  // Semaphore handles
  SemaphoreHandle_t data_ready_semhandle = NULL;
  //SemaphoreHandle_t spi_mutex = NULL;
  // from datasheet pg. 93:
  const int numFrameWords = 10;      // Number of words in a full ADS131M08 SPI frame 
  spiframe base_frame;
  bool firstRead = true;  // Flag to tell us if we are reading ADC data for the first time 
  signed long adcData;    // Location where DMA will store ADC data in memory, length defined elsewhere
  ADS131M08Hub();
  void txf_init();
  bool adc_initialize(uint8_t word_length);
  bool adc_set_word_length(uint8_t word_length);
  // end of from datasheet
  void set_channel_gain(uint8_t channel, ADS131M08_PGA_GAIN gain);
  //virtual void spi_setup() override;  
  void setup() override;
  void loop() override;
  void set_drdy_pin(InternalGPIOPin *pin) { drdy_pin_ = pin; }
  void set_sync_reset_pin(InternalGPIOPin *pin) { sync_reset_pin_ = pin; }
  void set_clock_frequency(float clock_frequency) { this->clock_frequency_ = clock_frequency; }
  void register_sensor_ac(int channel, sensor::Sensor *s) { sensors_ac[channel] = s; }
  void register_sensor_dc(int channel, sensor::Sensor *s) { sensors_dc[channel] = s; }
  void set_reference_voltage(float reference_voltage) { this->reference_voltage_ = reference_voltage; }  
  void set_osr(uint16_t osr) { this->osr_ = osr; }
  void dump_config() override;

  // from tpcorrea
  ADS131M08_PGA_GAIN pgaGain[ADC_CHANNELS] = {PGA_1}; // Store the current PGA gain settings for each channel
  int8_t is_data_ready_soft(uint8_t channel);
  bool is_data_ready();
  bool is_reset_status();
  bool is_lock_spi();
  bool set_drdy_format(uint8_t drdy_format);
  bool set_drdy_idle_state(uint8_t drdy_state);
  bool set_power_mode(uint8_t power_mode);
  bool set_channel_enable(uint8_t channel, bool enable);
  bool set_channel_pga(uint8_t channel, ADS131M08_PGA_GAIN pga);
  ADS131M08_PGA_GAIN get_channel_pga(uint8_t channel);
  void set_global_chop(uint16_t global_chop);
  void set_global_chop_delay(uint16_t delay);
  bool set_channel_input_selection(uint8_t channel, ADS131M08_INPUT_CHANNEL_MUX input);
  bool set_channel_offset_calibration(uint8_t channel, int32_t offset);
  bool set_channel_gain_calibration(uint8_t channel, uint32_t gain);
  bool set_channel_phase_calibration(uint8_t channel, int16_t phase_offset);
  bool set_dcblock_filter_disable(uint8_t channel, bool disable);
  void set_measure_rms(uint8_t channel, bool enable);
  float get_sampled_value(uint8_t channel) { return sampled_values_[channel]; }
  bool set_reg_osr();
  void set_full_scale(uint8_t channel, float scale);
  float get_full_scale(uint8_t channel);
  uint16_t get_id();
  uint16_t get_mode_reg();
  uint16_t get_clock_reg();
  uint16_t get_cfg_reg();
  AdcOutput read_adc_raw();
  AdcOutput read_adc_float();

 protected:
  static void IRAM_ATTR isr_handler(ADS131M08Hub *arg);  
  //volatile bool data_ready_{false};
  //static void isr(ADS131M08Hub *arg);  
  float reference_voltage_; 
  float clock_frequency_;
  InternalGPIOPin *drdy_pin_;
  InternalGPIOPin *sync_reset_pin_= {nullptr};
  sensor::Sensor *sensors_ac[MAX_CHANNELS] = {nullptr};
  sensor::Sensor *sensors_dc[MAX_CHANNELS] = {nullptr};
  float sampled_values_[ADC_CHANNELS];
  bool rms_enabled_[ADC_CHANNELS];
  bool rms_calc_req_{false};
  uint16_t osr_{3};
  uint8_t update_adc_word_length();
  void SET_IRAM read_single();
  std::pair<uint32_t, uint32_t> SET_IRAM read_multi();
  bool adc_lock(bool enable);
  bool adc_register_write(uint16_t address, uint16_t data);
  bool adc_register_write(uint16_t address, const uint16_str& data);
  uint16_str adc_register_read(uint8_t address, uint8_t nregs);
  bool adc_register_write_masked(uint8_t address, uint16_t value, uint16_t mask, int line);
  bool adc_register_write_masked(uint8_t start_address, const uint16_str& values, const uint16_str& masks, int line);
  uint16_t readRegister(uint8_t address);
  bool adc_reset_retry();
  bool adc_soft_reset();
  void adc_hard_reset();
  void adc_sync();
  void write_byte(uint8_t byte);
  bool write(uint32_t data, uint8_t adcWordLength);  
  uint8_t read_byte();
  void write_array(const spiframe& data);
  void SET_IRAM read_array(spiframe& buffer);
  void transfer_array(const spiframe& data_out, spiframe& data_in);
  uint16_t SET_IRAM get_crc(const spiframe& frame);
  bool SET_IRAM check_crc(const spiframe& frame_with_crc);
  size_t SET_IRAM add_crc(spiframe& frame, crc_pos crcpos);
  uint16_t SET_IRAM read_frame_crc(const spiframe& frame);
  uint16_t SET_IRAM crc(uint16_t crc_register, uint8_t data); 
  bool SET_IRAM set_frame_word(spiframe& frame, int w_index, uint16_t data); // write 16 bit data to first two bytes of word
  bool SET_IRAM set_frame_word(spiframe& frame, int w_index, uint32_t data);
  uint32_t SET_IRAM get_unsigned_frame_word(const spiframe& frame, int w_index, bool force_16bits = false);
  int32_t SET_IRAM get_sign_ext_frame_word(const spiframe& frame, int w_index);
  std::atomic<int> adc_init_{0};
  std::atomic<int> cs_ctr_{0}; // Counter to track nested CS enable/disable calls for proper handling of multiple transfers in a row
  std::atomic<uint16_t> isr_ctr_{0};
  void enable(const char *txt);
  void disable(const char *txt);
  struct chipselect {
    ADS131M08Hub* parent_{nullptr};
    const char *txt_;
    chipselect(ADS131M08Hub *parent, const char *txt = nullptr) {
      parent_ = parent;
      if(parent_ != nullptr)
        txt_ = txt;
        parent_->enable(txt_);
    }
    ~chipselect() {
       if(parent_ != nullptr) {
         parent_->disable(txt_);
         parent_ = nullptr;
       }
    }
  };
 private:

  uint8_t adc_word_length_{24};
  float conversion_factor_{1.2/8388608.0};
  const uint32_t sample_time_ = 40000; // 250 ms
  float sps_{0.0f};
  uint32_t num_samples_[ADC_CHANNELS];
  int64_t sample_sum_[ADC_CHANNELS];
  float sample_squared_sum_[ADC_CHANNELS];
// for debug only
  std::string frame_to_string(const spiframe& frame); 
  std::string conversion_frame_to_string(const spiframe& frame);
  std::string command_to_string(uint16_t cmdadr);
  void print_command_response_to_string(uint16_t cmdadr_sent, const spiframe& frame); 
  std::string rwreg_command_frame_to_string(const spiframe& frame);
  std::string status_to_string(uint16_t response);
  std::string reg_data_to_string(int address, uint16_t data, bool nameonly = false);
  std::string reg_addr_to_string(int address);
  std::string reg_config_to_string(int address, uint16_t data, bool nameonly = false);
  //temp
  int first_read_data {0};
};

#ifndef CHIP_SELECT
# if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
#  define CHIP_SELECT volatile chipselect cs(this, __FUNCTION__);
# else
#  define CHIP_SELECT volatile chipselect cs(this);
# endif
# define CHIP_SELECTx volatile chipselect cs(this);
#endif

} // namespace ads131m08
} // namespace esphome