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

#ifndef BombaPressurizadoraModel
#define BombaPressurizadoraModel

class BombaPressurizadora {
  public:

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

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

    String Mod_ID;
    String _ID;
    PinoModel _pinoEN;
    PinoModel _pinoCS;
    PinoModel _pinoINA;
    PinoModel _pinoINB;
    PinoModel _pinoPWM;
    int _canal = 0;

    double _Kp = 3.0;
    double _Ki = 2.2;
    double _Kd = 0.5;
    const int histerese = -5;
    bool bombaDesligadaPorPressao = false;
    PID* _PID = nullptr;

    int ZeroRampa = 0;
    int RampaMax = 1023;
    
    bool Iniciado = false;

    // Consumo
    Estado EstadoLeitura = Desligado;
    double PotenciaLeitura = 0;
    double _PressaoAtual = 0.0;

    // Entrada de dados
    Estado _EstadoControle = Desligado;
    double _PressaoSP = 0;

    void Inicializar() {
      if (Iniciado) {
        PrintTela(_ID + " ja inicializado");
        return;
      }
      
      _EstadoControle = Desligado;
      _pinoEN.Conectar(_EstadoControle);
      AtualizarLeitura();
      _pinoCS.Conectar();
      _pinoINA.Conectar(false);
      _pinoINB.Conectar(true);
      if (_pinoPWM.Definido()) {
        ledcSetup(_canal, 1000, 10);
        ledcAttachPin(_pinoPWM.num, _canal);
        PotenciaLeitura = 0;
        _PressaoSP = 0;
        ledcWrite(_canal, _PressaoSP);
      }

      _PID = new PID(&_PressaoAtual, &PotenciaLeitura, &_PressaoSP, _Kp, _Ki, _Kd, DIRECT);
      _PID->SetOutputLimits(ZeroRampa, RampaMax);
      _PID->SetMode(AUTOMATIC);

      PrintTela(_ID + " Iniciado");
      
      Iniciado = true;
    }

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

      delete _PID;
      _PID = nullptr;
      
      // Redefinir as configurações para os valores iniciais
      _pinoPWM.Desconectar();
      _pinoEN.Desconectar();
      _pinoCS.Desconectar();
      _pinoINA.Desconectar();
      _pinoINB.Desconectar();
      _pinoPWM.Desconectar();

      PrintTela(_ID + " Desligado");

      Iniciado = false;
    }

    void AtualizarLeitura() {
      EstadoLeitura = _pinoEN.get() == 1 ? Ligado : Desligado;
    }

    void AlterarStatusBomba() {
      bool status = _EstadoControle == Ligado;

      _pinoEN.set(status);
      
      AtualizarLeitura();
    }

    void Loop() {
      if (Iniciado) {
        // Supondo que PressaoAtual seja atualizado em AtualizarStatusSensor()
        if (_PressaoAtual >= (_PressaoSP + histerese)) {
          // Desliga a bomba se a pressão estiver acima do set point + histerese
          bombaDesligadaPorPressao = true;
        } else if (_PressaoAtual <= (_PressaoSP - histerese) && bombaDesligadaPorPressao) {
          // Permite que o PID atue novamente se a pressão cair abaixo do set point - histerese
          bombaDesligadaPorPressao = false;
        }

        if (_EstadoControle == Desligado || bombaDesligadaPorPressao) {
          PotenciaLeitura = ZeroRampa;
        } else {
          _PID->Compute();
          // Ajusta PotenciaAtual com base no PID
        }

        ledcWrite(_canal, PotenciaLeitura);

        AtualizarLeitura();
      }
    }


};


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

    for (auto* sensor : lista) {
      sensor->Desligar();  // Desliga cada sensor antes de remover
      PrintTela("Bomba Pressurizadora " + sensor->_ID + " desligada.");
      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() == 13) {
        String id = partes[0];
        bool conectar = partes[1] == "1";
        double pressaoSP = partes[2].toDouble();
        TiposBarramentos enB = (TiposBarramentos)partes[3].toInt();
        int pinoEN = partes[4].toInt();
        TiposBarramentos csB = (TiposBarramentos)partes[5].toInt();
        int pinoCS = partes[6].toInt();
        TiposBarramentos inaB = (TiposBarramentos)partes[7].toInt();
        int pinoINA = partes[8].toInt();
        TiposBarramentos inbB = (TiposBarramentos)partes[9].toInt();
        int pinoINB = partes[10].toInt();
        TiposBarramentos pwmB = (TiposBarramentos)partes[11].toInt();
        int pinoPWM = partes[12].toInt();

        if (conectar) {
          BombaPressurizadora* bomba = new BombaPressurizadora(Mod_ID, id);
          bomba->_PressaoSP = pressaoSP;
          bomba->_pinoEN = PinoModel(pinoEN, enB, _OUTPUT);
          bomba->_pinoCS = PinoModel(pinoCS, csB, _INPUT, DIGITAL);
          bomba->_pinoINA = PinoModel(pinoINA, inaB, _OUTPUT);
          bomba->_pinoINB = PinoModel(pinoINB, inbB, _OUTPUT);
          bomba->_pinoPWM = PinoModel(pinoPWM, pwmB, _PWM);
              
          bomba->Inicializar();
          lista.push_back(bomba);
          PrintTela("Bomba " + id + " inicializado com pressao SP" + String(pressaoSP));
        }
      } else {
        PrintTela("Configuração inválida para bomba pressurizadora: " + config);
      }
    }
  } else {
    PrintTela("Configuração de bomba pressurizadora não encontrada.");
  }
}


#endif