#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <ctime>

#if defined(_WIN32) || defined(_WIN64)
    #include <windows.h>
    void pausarMs(int milissegundos) {
        Sleep(milissegundos);
    }
#else
    #include <unistd.h>
    void pausarMs(int milissegundos) {
        usleep(milissegundos * 1000);
    }
#endif

using namespace std;

// Parametros Globais de Operacao da Caldeira
const float PRESSAO_NOMINAL = 8.0f;     // bar
const float PRESSAO_MINIMA = 6.5f;      // bar (limite inferior seguro)
const float TAXA_QUEDA_CRITICA = 0.4f;  // bar/segundo (indica possivel vazamento)
const float TEMP_MAXIMA = 180.0f;       // °C
const float NIVEL_MINIMO = 30.0f;       // %

// Estrutura para armazenar as leituras dos sensores
struct LeiturasSensores {
    float pressao;
    float temperatura;
    float nivelAgua;
};

// Estados do Sistema de Alerta
enum EstadoAlerta {
    SISTEMA_OK,
    ALERTA_PRESSAO_BAIXA,
    ALERTA_VAZAMENTO_DETECTADO,
    ALERTA_SOBRETEMPERATURA,
    ALERTA_NIVEL_CRITICO
};

// Funcao para simular a conversao ADC (4-20mA -> 0-3.3V no ESP32)
float converterAdcParaPressao(int valorADC) {
    // Exemplo: ADC 12-bits (0 a 4095)
    // 0 = 0.0 bar, 4095 = 10.0 bar
    return (static_cast<float>(valorADC) / 4095.0f) * 10.0f;
}

// Analisa os dados e define o estado do alarme
EstadoAlerta processarLogicaSeguranca(float pressaoAtual, float pressaoAnterior, 
                                      float tempoDecorridoSec, float temp, float nivel) {
    float deltaP = pressaoAnterior - pressaoAtual;
    float taxaQueda = (tempoDecorridoSec > 0) ? (deltaP / tempoDecorridoSec) : 0.0f;

    // 1. Queda brusca de pressao (Algoritmo dP/dt para detecção de vazamento)
    if (taxaQueda >= TAXA_QUEDA_CRITICA && pressaoAtual < PRESSAO_NOMINAL) {
        return ALERTA_VAZAMENTO_DETECTADO;
    }
    // 2. Pressao abaixo do limite operacional
    if (pressaoAtual < PRESSAO_MINIMA) {
        return ALERTA_PRESSAO_BAIXA;
    }
    // 3. Sobretemperatura
    if (temp > TEMP_MAXIMA) {
        return ALERTA_SOBRETEMPERATURA;
    }
    // 4. Nivel critico de agua
    if (nivel < NIVEL_MINIMO) {
        return ALERTA_NIVEL_CRITICO;
    }

    return SISTEMA_OK;
}

// Exibe a interface do monitor de forma organizada
void renderizarPainel(int ciclo, float pressao, float temp, float nivel, EstadoAlerta estado) {
    cout << "==================================================\n";
    cout << " SISTEMA EMBARCADO DE MONITORAMENTO DE CALDEIRAS  \n";
    cout << "==================================================\n";
    cout << " Ciclo de Leitura : " << ciclo << "\n";
    cout << " Pressao Atual    : " << fixed << setprecision(2) << pressao << " bar\n";
    cout << " Temperatura      : " << temp << " C\n";
    cout << " Nivel do Tanque  : " << nivel << " %\n";
    cout << "--------------------------------------------------\n";
    cout << " Status do Sistema: ";

    switch (estado) {
        case SISTEMA_OK:
            cout << "[OK] Funcionamento Normal (LED Verde)\n";
            break;
        case ALERTA_PRESSAO_BAIXA:
            cout << "[ALERTA] Pressao abaixo do limite seguro!\n";
            break;
        case ALERTA_VAZAMENTO_DETECTADO:
            cout << "[PERIGO] VAZAMENTO DETECTADO! Queda rapida de dP/dt! (Buzzer ON)\n";
            break;
        case ALERTA_SOBRETEMPERATURA:
            cout << "[ALERTA] Temperatura acima do limite!\n";
            break;
        case ALERTA_NIVEL_CRITICO:
            cout << "[ALERTA] Nivel de agua critico!\n";
            break;
    }
    cout << "==================================================\n\n";
}

int main() {
    srand(static_cast<unsigned int>(time(0)));

    // Condicoes iniciais normais
    float pressaoAtual = 8.0f;
    float pressaoAnterior = 8.0f;
    float temperatura = 160.0f;
    float nivelAgua = 85.0f;

    float intervaloAmostragem = 1.0f; // 1 segundo por ciclo

    cout << "Iniciando simulacao do monitor da caldeira...\n";
    pausarMs(1500);

    for (int ciclo = 1; ciclo <= 15; ciclo++) {
        // Limpa a tela no Windows
        #if defined(_WIN32) || defined(_WIN64)
            system("cls");
        #else
            system("clear");
        #endif

        // Atualiza a pressao anterior para calcular a taxa de variacao
        pressaoAnterior = pressaoAtual;

        // Simula o comportamento do sistema ao longo do tempo
        if (ciclo <= 5) {
            // Operacao estabilizada (pequeno ruído nos sensores)
            pressaoAtual = 8.0f - (rand() % 10) / 50.0f;
            temperatura = 160.0f + (rand() % 10) / 10.0f;
            nivelAgua -= 0.2f;
        } 
        else if (ciclo > 5 && ciclo <= 10) {
            // SIMULACAO DE VAZAMENTO: A pressao começa a cair rapidamente
            pressaoAtual -= 0.55f; 
            temperatura += 0.8f;
            nivelAgua -= 1.5f;
        } 
        else {
            // Pressao estabilizada em nivel baixo apos a queda
            pressaoAtual = 5.2f;
        }

        // Processa a logica de decisao
        EstadoAlerta estadoAtual = processarLogicaSeguranca(
            pressaoAtual, pressaoAnterior, intervaloAmostragem, temperatura, nivelAgua
        );

        // Exibe os dados
        renderizarPainel(ciclo, pressaoAtual, temperatura, nivelAgua, estadoAtual);

        // Aguarda o próximo ciclo de amostragem
        pausarMs(1000);
    }

    return 0;
}