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

#ifndef SensorMassaModel
#define SensorMassaModel

class SensorMassa : public ComponenteCAN {
  public:

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

    String Mod_ID;
    String _ID;
    int ID_Num;
    PinoModel _pinoDT;
    PinoModel _pinoSCK;

    long _Offset = 1996283;
    float _Escala = 50857.316406;
    float _OffsetMassa = 0.0;

    HX711 balanca = HX711();
    SimpleKalmanFilter filtro = SimpleKalmanFilter(0.05, 0.05, 0.25);

    float Massa = 0;
    float leitura = 0;

    bool Iniciado = false;

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

      if (_pinoDT.Definido() && _pinoSCK.Definido()) {
        balanca.begin(_pinoDT.num, _pinoSCK.num);
        balanca.set_offset(_Offset);
        balanca.set_scale(_Escala);
        //balanca->tare();

        Iniciado = true;

        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
      _pinoDT.Desconectar();
      _pinoSCK.Desconectar();
      Massa = 0;

      PrintTela(_ID + " Desligado");

      Iniciado = false;
    }

    void RequisitarDados() {
      AferirMassa();
    }

    std::vector<uint8_t> MontarMensagemCAN(CanMessagePosicaoDados posicao) {
      std::vector<uint8_t> data;
      data.push_back(static_cast<uint8_t>(posicao));
      data.push_back(ID_Num);
      switch (posicao) {
        case CanMessagePosicaoDados::Status: {
          data.push_back(Iniciado ? 1 : 0);
          break;
        }
        case CanMessagePosicaoDados::Dados1: {
          uint16_t massaEscalada = (uint16_t)(Massa * 100);
          uint16_t leituraEscalada = (uint16_t)(leitura * 100);
          data.push_back(leituraEscalada >> 8); data.push_back(leituraEscalada & 0xFF);
          data.push_back(massaEscalada >> 8); data.push_back(massaEscalada & 0xFF);
          break;
        }
      }
      return data;
    }

    static std::vector<uint8_t> ConfigurarSensor(std::vector<SensorMassa*>& lista, std::vector<uint8_t>& data, const String& Mod_ID) {
      std::vector<uint8_t> status;
      if (data.size() < 2) return status;
      CanMessagePosicaoDados posicao = (CanMessagePosicaoDados)data[0];
      uint8_t idNum = data[1];
      auto it = std::find_if(lista.begin(), lista.end(), [idNum](SensorMassa* s) { return s->ID_Num == idNum; });
      bool jaExiste = it != lista.end();
      SensorMassa* sensor;
      switch (posicao) {
        case CanMessagePosicaoDados::Config1: {
          if (data.size() < 8) return status;
          bool conectar = data[3] == 1;
          int pinoDt = data[4];
          int pinoSck = data[5];
          uint16_t offsetInt = ((uint16_t)data[6] << 8) | data[7];
          float offset = offsetInt / 100.0;
          if (conectar) {
            if (!jaExiste) {
              sensor = new SensorMassa(Mod_ID, "sMAS_" + String(idNum));
            }
            else {
              sensor = *it;
            }
            if (!sensor->Iniciado) {
              sensor->ID_Num = idNum;
              sensor->_pinoDT = PinoModel(pinoDt, CONTROLADOR, _INPUT, DIGITAL);
              sensor->_pinoSCK = PinoModel(pinoSck, CONTROLADOR, _OUTPUT);
              sensor->_OffsetMassa = offset;
              sensor->Inicializar();
              if (!jaExiste) {
                lista.push_back(sensor);
                PrintTela("Sensor de Massa adicionado via CAN: sMAS_" + String(idNum));
              }
              status = sensor->MontarMensagemCAN(CanMessagePosicaoDados::Status);
            }
          } else {
            if (jaExiste) {
              sensor = *it;
              sensor->Desligar();
              status = sensor->MontarMensagemCAN(CanMessagePosicaoDados::Status);
              delete sensor;
              lista.erase(it);
              PrintTela("Sensor de Massa removido via CAN: sMAS_" + String(idNum));
            }
          }
          break;
        }
      }
      return status;
    }

  private:
    void AferirMassa() {
      if (Iniciado) {
        leitura = balanca.get_units(5);
        float _leitura = -leitura;
        _leitura += _OffsetMassa;
        Massa = filtro.updateEstimate(_leitura);
      }
    }

};



#endif