#include "SerialService.h"
#include "Pinout.h"

#ifndef SensorFluxoModel
#define SensorFluxoModel

class SensorFluxo {
  public:

    static void InicializarLista(std::vector<SensorFluxo*>& lista, const String& parametros, const String& Mod_ID);

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

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

    unsigned long tempoAnterior = 0;
    unsigned int _Pulsos = 0;
    unsigned long _PeriodoTotal = 0;
    bool ultimaLeitura = false;

    bool Iniciado = false;

    // Consumo
    unsigned int _PulsosLeitura = 0;
    unsigned long _PeriodoTotalLeitura = 0;
    float _Vazao = 0;

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

      _pino.Conectar();

      Iniciado = _pino.Definido();

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

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

      // Redefinir as configurações para os valores iniciais
      _pino.Desconectar();

      ResetarEstado();

      PrintTela(_ID + " Desligado");

      Iniciado = false;
    }

    void RequisitarDados() {
      AtualizarLeitura();
    }

    void Loop() {
      if (Iniciado) {
        bool Leitura = _pino.get() == 1;
        if (Leitura != ultimaLeitura) {
          if (Leitura && !ultimaLeitura) {
            unsigned long tempoAtual = millis();
            unsigned long intervalo = (unsigned long)(tempoAtual - tempoAnterior); // Garante cálculo correto
            tempoAnterior = tempoAtual;

            _Pulsos++;
            _PeriodoTotal += intervalo;
          }

          ultimaLeitura = Leitura;
        }
      }
    }


    std::vector<uint8_t> MontarMensagemCAN() {
      std::vector<uint8_t> data;
    
      data.push_back(ID_Num);               // Byte 0 - ID do sensor
      data.push_back(Iniciado ? 1 : 0);     // Byte 1 - Status
    
      uint16_t vazaoEscalada = (uint16_t)(_Vazao * 100);
      data.push_back(vazaoEscalada >> 8);
      data.push_back(vazaoEscalada & 0xFF);
      
      return data;
    }


  private:

    void AtualizarLeitura() {
      if (Iniciado) {
        _PulsosLeitura = _Pulsos;
        _PeriodoTotalLeitura = _PeriodoTotal;
        _Vazao = CalcularVazao(_Pulsos, _PeriodoTotal);
  
        ReiniciarAmostragem();
      }
    }

    // Reseta o estado do sensor
    void ResetarEstado() {
      _Pulsos = 0;
      _PeriodoTotal = 0;
      tempoAnterior = millis();
      ultimaLeitura = _pino.get() == 1;
    }

    // Reinicia amostragem
    void ReiniciarAmostragem() {
      // Reseta os valores para a próxima amostragem
      _Pulsos = 0;
      _PeriodoTotal = 0;
    }

    float CalcularVazao(uint16_t pulsos, unsigned long periodoMs) {
      if (periodoMs == 0) return 0;

      float frequencia = (float)pulsos / (float)periodoMs * 1000.0;  // Hz
      const float Rh = 0.0047; // raio interno do tubo
      const float Rt = 0.0037; // raio interno do rotor

      float vazao_m3s = frequencia * 2.0 * PI * Rh * PI * (Rt * Rt); // m³/s
      float vazao_ml_s = vazao_m3s * 1e6; // ml/s

      return vazao_ml_s;
    }


};


// Função para inicializar os sensores de fluxo com IDs e pinos específicos
void SensorFluxo::InicializarLista(std::vector<SensorFluxo*>& lista, const String& parametros, const String& Mod_ID) {
  // Verifica se há sensores já na lista
  if (!lista.empty()) {
    PrintTela("Limpando lista de sensores de fluxo existente...");

    for (auto* sensor : lista) {
      sensor->Desligar();  // Desliga cada sensor antes de remover
      PrintTela("Sensor de Fluxo " + sensor->_ID + " desligado.");
      delete sensor;
    }

    lista.clear();  // Limpa a lista após desligar todos os itens
  }

  if (parametros.length() > 0) {
    std::vector<String> _config = SplitString(parametros, SplitConfig);  // Divide a configuração por vírgulas

    for (const String& config : _config) {
      std::vector<String> partes = SplitString(config, SplitSubParams);  // Divide cada configuração pelo '-'

      if (partes.size() == 4) {
        String id = partes[0];
        bool conectar = partes[1] == "1";
        TiposBarramentos pinoB = (TiposBarramentos)partes[2].toInt();
        int pino = partes[3].toInt();

        if (conectar) {
          SensorFluxo* sensor = new SensorFluxo(Mod_ID, id);
          sensor->_pino = PinoModel(pino, pinoB, _INPUT, DIGITAL);
          sensor->Inicializar();

          lista.push_back(sensor);
          PrintTela("Sensor de fluxo " + id + " inicializado no pino " + String(pino));
        } 
      } else {
        PrintTela("Configuração inválida para sensor de fluxo: " + config);
      }
    }
  } else {
    PrintTela("Configuração de sensor de fluxo não encontrada.");
  }
}


#endif