#include "SerialService.h"
#include "Pinout.h"
#include "Utils.h"
#include "IComponenteCAN.h"
#include "I2CService.h"

#include <Arduino.h>
#include <vector>
#include <math.h>
#include <limits.h>

#ifndef SensorTemperaturaNtcModel
#define SensorTemperaturaNtcModel

/*
 * SensorTemperaturaNtc - versão produto
 *
 * Topologia física da placa:
 *
 *  Retorno do motor ---- Rserie 4k7 ----+---- ADC / ADS1115
 *                                        |
 *                                      Rgnd 6k8
 *                                        |
 *                                       GND
 *
 * Logo, visto pelo retorno do motor, a placa adiciona uma carga:
 *
 *      Rcarga = Rserie + Rgnd = 11k5
 *
 * e a tensão realmente lida pelo ADC é:
 *
 *      Vadc = Vretorno * Rgnd / (Rserie + Rgnd)
 *
 * A classe reconstrói Vretorno antes de calcular o NTC.
 *
 *
 * ntcGnd = false:
 *
 *        5 V
 *         |
 *        NTC
 *         |
 *      Vretorno ------- Rserie ------- ADC
 *         |                            |
 *      Rfixo 10k                      Rgnd
 *         |                            |
 *        GND                          GND
 *
 *
 * ntcGnd = true:
 *
 *        5 V
 *         |
 *      Rfixo 10k
 *         |
 *      Vretorno ------- Rserie ------- ADC
 *         |                            |
 *        NTC                          Rgnd
 *         |                            |
 *        GND                          GND
 *
 *
 * Para EXPANSOR_ADS:
 * - usa geração do Wire/I2C;
 * - faz uma única aquisição lógica por ciclo;
 * - preserva a última amostra válida em falhas;
 * - invalida o lifecycle após falhas consecutivas;
 * - o retry externo pode reinicializar o sensor.
 */
class SensorTemperaturaNtc : public ComponenteCAN {
  public:
    String ID;
    uint8_t ID_Num = 0;
    PinoModel _pino;

    // Mantido público para compatibilidade com código legado.
    bool Iniciado = false;

    int leitura = -1;
    double temperatura = NAN;

    // Tensão REAL medida no pino do ADC/ADS, depois do divisor 4k7/6k8.
    double tensao = NAN;

    float OffsetTemperatura = 0.0f;

    SensorTemperaturaNtc() {}

    /*
     * Mantém exatamente o contrato histórico do construtor.
     *
     * ntcGnd:
     *   false = NTC no lado de 5 V
     *   true  = NTC no lado de GND
     */
    SensorTemperaturaNtc(
      const String& id,
      uint8_t idNum,
      int pino,
      TiposBarramentos tipoBarramento,
      int canalMux = -1,
      float offsetTemperatura = 0.0f,
      bool ntcGnd = false
    ) :
      ID(id),
      ID_Num(idNum),
      _pino(
        PinoModel(
          pino,
          tipoBarramento,
          _INPUT,
          ANALOGICO,
          idNum,
          canalMux
        )
      ),
      OffsetTemperatura(offsetTemperatura),
      _ntcGnd(ntcGnd),
      _tipoBarramento(tipoBarramento)
    {
    }

    bool EstaIniciado() {
      bool iniciado;
      uint32_t geracaoInicializacao;

      portENTER_CRITICAL(&_snapshotLock);
      iniciado = Iniciado;
      geracaoInicializacao = _geracaoI2CInicializacao;
      portEXIT_CRITICAL(&_snapshotLock);

      if (!iniciado) {
        return false;
      }

      // ADC interno não depende do lifecycle do Wire.
      if (_tipoBarramento != TiposBarramentos::EXPANSOR_ADS) {
        return true;
      }

      const uint32_t geracaoAtual =
        I2CService::GeracaoBarramento();

      return
        I2CService::I2CIniciado &&
        I2CService::AdsIniciado &&
        geracaoAtual != 0 &&
        geracaoInicializacao == geracaoAtual;
    }

    bool PossuiAmostraValida() {
      bool valor;

      portENTER_CRITICAL(&_snapshotLock);
      valor = _possuiAmostraValida;
      portEXIT_CRITICAL(&_snapshotLock);

      return valor;
    }

    uint8_t FalhasConsecutivas() {
      uint8_t valor;

      portENTER_CRITICAL(&_snapshotLock);
      valor = _falhasConsecutivas;
      portEXIT_CRITICAL(&_snapshotLock);

      return valor;
    }

    uint32_t TotalFalhasLeitura() {
      uint32_t valor;

      portENTER_CRITICAL(&_snapshotLock);
      valor = _totalFalhasLeitura;
      portEXIT_CRITICAL(&_snapshotLock);

      return valor;
    }

    uint32_t IdadeUltimaAmostraValidaMs() {
      uint32_t ultima;
      bool possui;

      portENTER_CRITICAL(&_snapshotLock);
      ultima = _ultimaAmostraValidaMs;
      possui = _possuiAmostraValida;
      portEXIT_CRITICAL(&_snapshotLock);

      if (!possui || ultima == 0) {
        return UINT32_MAX;
      }

      return (uint32_t)(millis() - ultima);
    }

    void Inicializar() {
      if (EstaIniciado()) {
        MostrarLog("Sensor ja inicializado");
        return;
      }

      // Limpa lifecycle, mas preserva a última leitura válida.
      AtualizarEstadoIniciado(false);

      if (_tipoBarramento == TiposBarramentos::EXPANSOR_ADS) {
        if (!I2CService::I2CIniciado) {
          MostrarLog(
            "Sensor nao iniciado | I2C indisponivel"
          );
          return;
        }

        if (!I2CService::AdsIniciado) {
          MostrarLog(
            "Sensor nao iniciado | ADS1115 indisponivel"
          );
          return;
        }
      }

      _pino.Conectar();

      if (!_pino.Definido() || !_pino.Conectado) {
        MostrarLog(
          "Sensor nao iniciado | pino/barramento indisponivel"
        );
        return;
      }

      /*
       * Se algum dia esta classe voltar ao ADC interno,
       * preserva a configuração histórica de 12 bits / 11 dB.
       *
       * Para o ADS1115 isso não é usado.
       */
      if (_tipoBarramento == TiposBarramentos::CONTROLADOR) {
        analogReadResolution(12);
        analogSetPinAttenuation(
          _pino.num,
          ADC_11db
        );
      }

      AtualizarEstadoIniciado(true);

      portENTER_CRITICAL(&_snapshotLock);
      _falhasConsecutivas = 0;
      portEXIT_CRITICAL(&_snapshotLock);

      MostrarLog(
        "Sensor iniciado"
        " | canal=" + String(_pino.num) +
        " | ntc_gnd=" + String(_ntcGnd ? 1 : 0) +
        " | geracao=" +
        String(_geracaoI2CInicializacao)
      );
    }

    void Desligar() {
      _pino.Desconectar();
      AtualizarEstadoIniciado(false);

      MostrarLog("Sensor desligado");
    }

    void RequisitarDados() {
      if (!EstaIniciado()) {
        /*
         * Caso a geração tenha mudado, força Iniciado=false
         * para que o retry periódico da firmware enxergue
         * corretamente a necessidade de reinicialização.
         */
        bool estavaMarcadoIniciado;

        portENTER_CRITICAL(&_snapshotLock);
        estavaMarcadoIniciado = Iniciado;
        portEXIT_CRITICAL(&_snapshotLock);

        if (
          estavaMarcadoIniciado &&
          _tipoBarramento ==
            TiposBarramentos::EXPANSOR_ADS
        ) {
          AtualizarEstadoIniciado(false);
        }

        return;
      }

      AferirTemperatura();
    }

    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);

      const bool iniciado =
        EstaIniciado();

      int snapLeitura;
      double snapTemperatura;
      double snapTensao;
      bool snapValido;

      portENTER_CRITICAL(&_snapshotLock);
      snapLeitura = leitura;
      snapTemperatura = temperatura;
      snapTensao = tensao;
      snapValido = _possuiAmostraValida;
      portEXIT_CRITICAL(&_snapshotLock);

      switch (posicao) {
        case CanMessagePosicaoDados::Status: {
          data.push_back(
            iniciado ? 1 : 0
          );
          break;
        }

        case CanMessagePosicaoDados::Dados1: {
          /*
           * Mantém o contrato CAN atual:
           *
           * [2..3] raw ADC normalizado 0..4095
           * [4..5] temperatura * 100
           * [6..7] tensão no PINO ADC em mV
           */

          uint16_t leituraAdc =
            snapValido &&
            snapLeitura >= 0
              ? static_cast<uint16_t>(
                  snapLeitura
                )
              : 0xFFFF;

          int16_t temperaturaInt =
            snapValido &&
            isfinite(snapTemperatura)
              ? static_cast<int16_t>(
                  constrain(
                    (long)lround(
                      snapTemperatura *
                      100.0
                    ),
                    (long)INT16_MIN + 1,
                    (long)INT16_MAX
                  )
                )
              : INT16_MIN;

          uint16_t tensaoMv =
            snapValido &&
            isfinite(snapTensao) &&
            snapTensao >= 0.0
              ? static_cast<uint16_t>(
                  constrain(
                    (long)lround(
                      snapTensao *
                      1000.0
                    ),
                    0L,
                    65534L
                  )
                )
              : 0xFFFF;

          data.push_back(
            static_cast<uint8_t>(
              leituraAdc >> 8
            )
          );
          data.push_back(
            static_cast<uint8_t>(
              leituraAdc & 0xFF
            )
          );

          data.push_back(
            static_cast<uint8_t>(
              (uint16_t)temperaturaInt >> 8
            )
          );
          data.push_back(
            static_cast<uint8_t>(
              (uint16_t)temperaturaInt & 0xFF
            )
          );

          data.push_back(
            static_cast<uint8_t>(
              tensaoMv >> 8
            )
          );
          data.push_back(
            static_cast<uint8_t>(
              tensaoMv & 0xFF
            )
          );

          break;
        }

        default:
          break;
      }

      return data;
    }

  private:
    bool DebugMode = false;

    /*
     * false:
     *   5V -> NTC -> retorno -> Rfixo -> GND
     *
     * true:
     *   5V -> Rfixo -> retorno -> NTC -> GND
     */
    bool _ntcGnd = false;

    TiposBarramentos _tipoBarramento =
      TiposBarramentos::CONTROLADOR;

    portMUX_TYPE _snapshotLock =
      portMUX_INITIALIZER_UNLOCKED;

    uint8_t _falhasConsecutivas = 0;
    uint32_t _totalFalhasLeitura = 0;

    uint32_t _geracaoI2CInicializacao = 0;

    bool _possuiAmostraValida = false;
    uint32_t _ultimaAmostraValidaMs = 0;

    /*
     * Hardware real.
     */
    static constexpr float Vs = 5.0f;

    static constexpr float Rfixo =
      10000.0f;

    static constexpr float Rserie =
      4700.0f;

    static constexpr float Rgnd =
      6800.0f;

    /*
     * Do ponto de vista do Vretorno:
     *
     * retorno -> 4k7 -> ADC -> 6k8 -> GND
     *
     * equivale a 11k5 para GND.
     */
    static constexpr float Rcarga =
      Rserie + Rgnd;

    /*
     * ADS1115 atual:
     * I2CService usa GAIN_ONE.
     *
     * readADC_SingleEnded() é convertido no service
     * de 0..32767 para 0..4095.
     *
     * Portanto:
     *
     * 4095 <=> 4.096 V
     */
    static constexpr float
      FullScaleAdsV = 4.096f;

    /*
     * O máximo físico no ADC devido ao divisor 4k7/6k8 é:
     *
     * 5V * 6k8 / (4k7 + 6k8)
     * ~= 2.9565 V
     */
    static constexpr float
      TensaoAdcMaxFisicaV =
        Vs * Rgnd / Rcarga;

    static constexpr float
      MargemTensaoV = 0.010f;

    static constexpr float Beta =
      3950.0f;

    static constexpr float T0K =
      298.15f;

    static constexpr float Rntc25 =
      10000.0f;

    static constexpr float
      TemperaturaMinC = -40.0f;

    static constexpr float
      TemperaturaMaxC = 150.0f;

    /*
     * ADS1115 já é delta-sigma.
     * 4 amostras por NTC são suficientes para uma grandeza lenta.
     *
     * 4 NTC * 4 conversões * 2 Hz = 32 conversões/s.
     */
    static constexpr int
      QuantidadeAmostras = 3;

    /*
     * Filtro final leve.
     * O valor só entra aqui depois de passar por todas as validações.
     */
    static constexpr float
      AlphaTemperatura = 0.35f;

    static constexpr uint8_t
      LimiteFalhasAntesReinit = 3;

    void MostrarLog(
      const String& mensagem
    ) {
      if (DebugMode) {
        PrintTela(
          "[TMP " +
          ID +
          "] " +
          mensagem
        );
      }
    }

    void AtualizarEstadoIniciado(
      bool iniciado
    ) {
      const uint32_t geracao =
        iniciado &&
        _tipoBarramento ==
          TiposBarramentos::EXPANSOR_ADS
          ? I2CService::GeracaoBarramento()
          : 0;

      portENTER_CRITICAL(&_snapshotLock);

      Iniciado = iniciado;
      _geracaoI2CInicializacao =
        geracao;

      portEXIT_CRITICAL(&_snapshotLock);
    }

    void RegistrarFalhaAquisicao(
      const String& motivo
    ) {
      uint8_t falhas;

      portENTER_CRITICAL(&_snapshotLock);

      if (
        _falhasConsecutivas <
        UINT8_MAX
      ) {
        _falhasConsecutivas++;
      }

      _totalFalhasLeitura++;
      falhas =
        _falhasConsecutivas;

      portEXIT_CRITICAL(&_snapshotLock);

      MostrarLog(
        "Falha de leitura " +
        String(falhas) +
        "/" +
        String(
          LimiteFalhasAntesReinit
        ) +
        " | " +
        motivo
      );

      /*
       * Nunca sobrescreve o último valor bom com NaN.
       *
       * Se a falha persistir, o sensor perde o estado
       * Iniciado e entra no retry controlado da firmware.
       */
      if (
        falhas >=
        LimiteFalhasAntesReinit
      ) {
        AtualizarEstadoIniciado(false);

        MostrarLog(
          "Sensor marcado para "
          "reinicializacao controlada"
        );
      }
    }

    void RegistrarSucessoAquisicao() {
      portENTER_CRITICAL(&_snapshotLock);
      _falhasConsecutivas = 0;
      portEXIT_CRITICAL(&_snapshotLock);
    }

    /*
     * Converte o raw 0..4095 recebido do I2CService
     * para a tensão REAL no pino do ADS1115.
     */
    bool ConverterRawParaTensaoAdc(
      int raw,
      float& vAdc
    ) {
      if (
        raw < 0 ||
        raw > 4095
      ) {
        return false;
      }

      if (
        _tipoBarramento ==
        TiposBarramentos::EXPANSOR_ADS
      ) {
        vAdc =
          ((float)raw / 4095.0f) *
          FullScaleAdsV;
      }
      else {
        /*
         * Fallback histórico para ADC de 12 bits.
         * Esta versão produto está otimizada para ADS.
         *
         * Se voltar ao ADC interno, recomenda-se usar
         * analogReadMilliVolts() no PinoModel para calibração absoluta.
         */
        vAdc =
          ((float)raw / 4095.0f) *
          3.3f;
      }

      if (!isfinite(vAdc)) {
        return false;
      }

      /*
       * Com o divisor físico, o ADS jamais deveria receber
       * mais que aproximadamente 2.9565 V.
       *
       * Deixamos pequena tolerância para resistores/medição.
       */
      if (
        _tipoBarramento ==
          TiposBarramentos::EXPANSOR_ADS &&
        (
          vAdc <
            -MargemTensaoV ||
          vAdc >
            TensaoAdcMaxFisicaV +
            0.050f
        )
      ) {
        return false;
      }

      return true;
    }

    /*
     * Reconstrói a tensão do nó original do sensor,
     * antes do divisor 4k7/6k8.
     *
     * Vadc =
     *   Vretorno *
     *   Rgnd /
     *   (Rserie + Rgnd)
     *
     * logo:
     *
     * Vretorno =
     *   Vadc *
     *   (Rserie + Rgnd) /
     *   Rgnd
     */
    bool CalcularTensaoRetorno(
      float vAdc,
      float& vRetorno
    ) {
      if (
        !isfinite(vAdc) ||
        vAdc < 0.0f
      ) {
        return false;
      }

      vRetorno =
        vAdc *
        Rcarga /
        Rgnd;

      if (!isfinite(vRetorno)) {
        return false;
      }

      if (
        vRetorno <=
          MargemTensaoV ||
        vRetorno >=
          Vs -
          MargemTensaoV
      ) {
        return false;
      }

      return true;
    }

    /*
     * Calcula Rntc considerando também a carga
     * criada pelo divisor 4k7 + 6k8.
     */
    bool CalcularResistenciaNtc(
      float vRetorno,
      float& resistenciaNtc
    ) {
      if (
        !isfinite(vRetorno) ||
        vRetorno <=
          MargemTensaoV ||
        vRetorno >=
          Vs -
          MargemTensaoV
      ) {
        return false;
      }

      if (_ntcGnd) {
        /*
         * 5V -> Rfixo -> retorno -> NTC -> GND
         *
         * Abaixo do retorno temos:
         *
         * NTC || Rcarga
         *
         * Primeiro calculamos a resistência equivalente
         * inferior do divisor:
         *
         * Req =
         *   Rfixo *
         *   Vretorno /
         *   (Vs - Vretorno)
         */
        const float rEquivalente =
          Rfixo *
          vRetorno /
          (Vs - vRetorno);

        if (
          !isfinite(rEquivalente) ||
          rEquivalente <= 0.0f
        ) {
          return false;
        }

        /*
         * 1 / Req =
         *   1 / Rntc +
         *   1 / Rcarga
         */
        const float inversoRntc =
          (1.0f / rEquivalente) -
          (1.0f / Rcarga);

        if (
          !isfinite(inversoRntc) ||
          inversoRntc <= 0.0f
        ) {
          return false;
        }

        resistenciaNtc =
          1.0f /
          inversoRntc;
      }
      else {
        /*
         * 5V -> NTC -> retorno -> Rfixo -> GND
         *
         * Abaixo do retorno temos:
         *
         * Rfixo || Rcarga
         */
        const float rInferior =
          (Rfixo * Rcarga) /
          (Rfixo + Rcarga);

        if (
          !isfinite(rInferior) ||
          rInferior <= 0.0f
        ) {
          return false;
        }

        /*
         * Vretorno =
         *
         * Vs *
         * rInferior /
         * (Rntc + rInferior)
         *
         * logo:
         *
         * Rntc =
         *   rInferior *
         *   (Vs - Vretorno) /
         *   Vretorno
         */
        resistenciaNtc =
          rInferior *
          (Vs - vRetorno) /
          vRetorno;
      }

      return
        isfinite(resistenciaNtc) &&
        resistenciaNtc > 0.0f;
    }

    bool CalcularTemperaturaC(
      float resistenciaNtc,
      float& temperaturaC
    ) {
      if (
        !isfinite(resistenciaNtc) ||
        resistenciaNtc <= 0.0f
      ) {
        return false;
      }

      const float termoLog =
        logf(
          resistenciaNtc /
          Rntc25
        );

      if (!isfinite(termoLog)) {
        return false;
      }

      const float inversoT =
        (1.0f / T0K) +
        (termoLog / Beta);

      if (
        !isfinite(inversoT) ||
        inversoT <= 0.0f
      ) {
        return false;
      }

      temperaturaC =
        (1.0f / inversoT) -
        273.15f +
        OffsetTemperatura;

      if (
        !isfinite(temperaturaC) ||
        temperaturaC <
          TemperaturaMinC ||
        temperaturaC >
          TemperaturaMaxC
      ) {
        return false;
      }

      temperaturaC =
        roundf(
          temperaturaC *
          100.0f
        ) /
        100.0f;

      return true;
    }

    void PublicarAmostraValida(
      int novaLeitura,
      float novaTensaoAdc,
      float novaTemperatura
    ) {
      float temperaturaPublicada =
        novaTemperatura;

      portENTER_CRITICAL(&_snapshotLock);

      if (
        _possuiAmostraValida &&
        isfinite(temperatura)
      ) {
        temperaturaPublicada =
          AlphaTemperatura *
            novaTemperatura +
          (
            1.0f -
            AlphaTemperatura
          ) *
            (float)temperatura;
      }

      leitura =
        novaLeitura;

      /*
       * Mantemos no CAN a tensão que realmente
       * chegou ao ADC, depois do divisor 4k7/6k8.
       */
      tensao =
        novaTensaoAdc;

      temperatura =
        roundf(
          temperaturaPublicada *
          100.0f
        ) /
        100.0f;

      _possuiAmostraValida =
        true;

      _ultimaAmostraValidaMs =
        millis();

      portEXIT_CRITICAL(&_snapshotLock);
    }

    void AferirTemperatura() {
      /*
       * UMA única aquisição lógica.
       *
       * No EXPANSOR_ADS:
       * PinoModel::get(N) ->
       * I2CService::RealizarLeituraADS()
       *
       * O ownership do I2C fica mantido durante
       * todas as N conversões.
       */
      const int novaLeitura =
        _pino.get(
          QuantidadeAmostras
        );

      if (novaLeitura < 0) {
        RegistrarFalhaAquisicao(
          "falha ao obter amostra ADC"
        );
        return;
      }

      float novaTensaoAdc = NAN;

      if (
        !ConverterRawParaTensaoAdc(
          novaLeitura,
          novaTensaoAdc
        )
      ) {
        RegistrarFalhaAquisicao(
          "raw/tensao ADC invalido"
          " | raw=" +
          String(novaLeitura)
        );
        return;
      }

      float vRetorno = NAN;

      if (
        !CalcularTensaoRetorno(
          novaTensaoAdc,
          vRetorno
        )
      ) {
        RegistrarFalhaAquisicao(
          "tensao de retorno invalida"
          " | raw=" +
          String(novaLeitura) +
          " | Vadc=" +
          String(
            novaTensaoAdc,
            3
          )
        );
        return;
      }

      float resistenciaNtc = NAN;

      if (
        !CalcularResistenciaNtc(
          vRetorno,
          resistenciaNtc
        )
      ) {
        RegistrarFalhaAquisicao(
          "resistencia NTC invalida"
          " | Vadc=" +
          String(
            novaTensaoAdc,
            3
          ) +
          " | Vret=" +
          String(
            vRetorno,
            3
          )
        );
        return;
      }

      float novaTemperatura = NAN;

      if (
        !CalcularTemperaturaC(
          resistenciaNtc,
          novaTemperatura
        )
      ) {
        RegistrarFalhaAquisicao(
          "temperatura fora da faixa"
          " | Rntc=" +
          String(
            resistenciaNtc,
            1
          ) +
          " | Vret=" +
          String(
            vRetorno,
            3
          )
        );
        return;
      }

      RegistrarSucessoAquisicao();

      PublicarAmostraValida(
        novaLeitura,
        novaTensaoAdc,
        novaTemperatura
      );

      MostrarLog(
        "Raw=" +
        String(novaLeitura) +
        " | Vadc=" +
        String(
          novaTensaoAdc,
          3
        ) +
        " V | Vret=" +
        String(
          vRetorno,
          3
        ) +
        " V | Rntc=" +
        String(
          resistenciaNtc,
          1
        ) +
        " ohm | T=" +
        String(
          novaTemperatura,
          2
        ) +
        " C"
      );
    }
};

#endif