#include "SerialService.h"
#include "Pinout.h"
#include "Utils.h"
#include <SimpleKalmanFilter.h>

#ifndef SensorTemperaturaModel
#define SensorTemperaturaModel

class SensorTemperatura {
  public:

    static std::vector<uint8_t> ConfigurarSensor(std::vector<SensorTemperatura*>& lista, std::vector<uint8_t>& data, const String& Mod_ID);

    SensorTemperatura(String _modID, String _id) {
      Mod_ID = _modID;
      _ID = _id;
    }

    // Definições
    String Mod_ID = "";
    String _ID;
    int ID_Num;
    PinoModel _pino;

    double leitura = 0;
    double temperatura = -1;

    //SimpleKalmanFilter filtro = SimpleKalmanFilter(5, 15, 0.01);

    bool Iniciado = false;
    bool Checando = false;

    void Inicializar() {
      if (Iniciado) {
        PrintTela(_ID + " ja inicializado");
        return;
      }

      leitura = 0;

      _pino.Conectar(); // Conecta o pino antes de criar a tarefa

      Iniciado = _pino.Definido();

      if (Iniciado) {
        PrintTela(_ID + " iniciado");
      }
      else {
        PrintTela(_ID + " nao iniciado");
      }
    }

    void Desligar() {
      if (!Iniciado) {
        PrintTela(_ID + " nao esta inicializado");
        return;
      }

      _pino.Desconectar(); // Desconecta o pino

      PrintTela(_ID + " Desligado");

      Iniciado = false;
    }

    void AferirTemperatura() {
      if (Iniciado) {
        leitura = _pino.get(5);
        //leitura = filtro.updateEstimate(leitura);
        temperatura = CalcularTemperatura((float)leitura);
      }
    }

    void RequisitarDados() {
      AferirTemperatura();
    }

    std::vector<uint8_t> MontarMensagemCAN(CanMessagePosicaoDados posicao) {
      std::vector<uint8_t> data;
      data.push_back(ID_Num);
      data.push_back(static_cast<uint8_t>(posicao));
      switch (posicao) {
        case CanMessagePosicaoDados::Status: {
          data.push_back(Iniciado ? 1 : 0);
          break;
        }
        case CanMessagePosicaoDados::Dados1: {
          int16_t leituraInt = static_cast<int16_t>(round(temperatura * 100.0f));
          data.push_back((uint8_t)(leituraInt >> 8));
          data.push_back((uint8_t)(leituraInt & 0xFF));
          break;
        }
      }
      return data;
    }


  private:
    float CalcularTemperatura(float leitura, float offset = 0.0f) {
      const float Vs = 5.0;         // Tensão de referência (divisor)
      const float Beta = 3950.0;    // Coeficiente Beta do NTC
      const float To = 298.15;      // 25°C em Kelvin
      const float Ro = 10000.0;     // NTC 10k
      const float adcMax = 4095.0;  // ADC de 12 bits
    
      if (leitura < 200) return -1.0; // ignora valores muito baixos (desconectado?)
    
      float Vout = leitura * Vs / adcMax;
    
      if (Vout <= 0.001) return -100.0; // proteção para log(0)
      if (Vout >= Vs) return NAN;
    
      float Rt = Ro * (Vout / (Vs - Vout)); // NTC em cima
      // float Rt = Ro * ((Vs - Vout) / Vout); // NTC embaixo, se for o caso
    
      float T = 1.0 / (1.0 / To + log(Rt / Ro) / Beta);
      float Tc = T - 273.15 + offset;
    
      return roundf(Tc * 100.0f) / 100.0f; // arredonda para 2 casas
    }
};

std::vector<uint8_t> SensorTemperatura::ConfigurarSensor(std::vector<SensorTemperatura*>& lista, std::vector<uint8_t>& data, const String& Mod_ID) {
  std::vector<uint8_t> status;
  if (data.size() < 3) return status;
  uint8_t idNum = data[1];
  CanMessagePosicaoDados posicao = (CanMessagePosicaoDados)data[2];
  switch (posicao) {
    case CanMessagePosicaoDados::Config1: {
      if (data.size() < 7) return status;
      bool conectar = data[4] == 1;
      TiposBarramentos tipoBarramento = (TiposBarramentos)data[5];
      int pino = data[6];
      // Verifica se sensor já existe
      auto it = std::find_if(lista.begin(), lista.end(), [idNum](SensorTemperatura* s) { return s->ID_Num == idNum; });
      if (conectar) {
        if (it == lista.end()) {
          SensorTemperatura* sensor = new SensorTemperatura(Mod_ID, "sTMP_" + String(idNum));
          sensor->ID_Num = idNum;
          sensor->_pino = PinoModel(pino, tipoBarramento, _INPUT, ANALOGICO);
          sensor->Inicializar();
          lista.push_back(sensor);
          PrintTela("Sensor de temperatura adicionado via CAN: sTMP_" + String(idNum));
          status = sensor->MontarMensagemCAN(CanMessagePosicaoDados::Status);
        }
      } else {
        // Desconectar sensor
        if (it != lista.end()) {
          SensorTemperatura* sensor = *it;
          sensor->Desligar();
          status = sensor->MontarMensagemCAN(CanMessagePosicaoDados::Status);
          delete sensor;
          lista.erase(it);
          PrintTela("Sensor de temperatura removido via CAN: sTMP_" + String(idNum));
        }
      }
      break;
    }
  }
  return status;
}

#endif