#include <Arduino.h>
#include "Button.h"
#include "ACI_10K_an.h"
#include "LED.h" // Biblioteca para controle de LEDs
#include <Wire.h> // Biblioteca para comunicação I2C
#include "LiquidCrystal_I2C.h" // Biblioteca para LCD I2C

// Definições globais
Button button2(7);//AMARELO alterVeloc
Button button5(8);//PRETO 
Button button1(A2);//AZUL bombeamento
Button button3(A3);//VERMELHO ionizador
Button button4(A4);//VERDE oscilador

const int leds[] = {9, 6, 5, 4}; // Pinos dos LEDs
LED led0(leds[0]); 
LED led1(leds[1]); 
LED led2(leds[2]); 
LED led3(leds[3]); 
int autVeloc = 0;
int alterVeloc = 1;
int nivelTanque = HIGH;
int value;
unsigned long tempoAnterior = 0;
const int intervaloLeitura = 100; // Tempo de leitura sem bloquear execução
const int temp = 2000; // Valor fixo para o tempo de LEDs

// Configuração do LCD I2C
// Endereço I2C do LCD (comum é 0x27 ou 0x3F)
LiquidCrystal_I2C lcd(0x27, 16, 2); 

// Protótipos das funções
void configurarPinos();
void velocidade();
void autaTemperatura();
void bombeamento();
void oscilador();
void ionizador();
void atualizarDisplay();
void autocontroleTermico();
int fanSpeedPWM = 0; // Valor PWM para o ventilador (0-255)
// --- NOVAS VARIÁVEIS PARA O MODO AUTOMÁTICO ---
bool modoAutomatico = false; // Alterna entre manual (botão) e automático (temperatura)
float lerTemperatura();
float t = lerTemperatura();

void setup() {
    Serial.begin(9600);
    configurarPinos();
    button1.begin();
    button2.begin();
    button3.begin();
    button4.begin();
    button5.begin();
    pinMode(2, INPUT_PULLUP);
    // Inicializa o gerador de números aleatórios com uma leitura de pino analógico.
  // Isso garante que a sequência de números aleatórios seja diferente a cada vez que o Arduino é ligado.
  randomSeed(analogRead(A0));
    
    // Inicializa o LCD
    lcd.init();
    lcd.backlight();
    lcd.setCursor(0, 0);
    lcd.print("Iniciando...");
    lcd.setCursor(0, 1);
    lcd.print("Aguarde...");
    delay(2000);
    lcd.clear();
}

void loop() {
    velocidade();
    autaTemperatura();
    bombeamento();
    oscilador();
    ionizador();
    autocontroleTermico();
    atualizarDisplay(); // Chamada da nova função de atualização do display

    // Atualiza a leitura da temperatura
    if (millis() - tempoAnterior >= intervaloLeitura) {
        tempoAnterior = millis();
        float temperatura = lerTemperatura();
        Serial.print("Temperatura: ");
        Serial.print(temperatura);
        Serial.println(" C");
    }
    // Verificamos o botão 5 (pino 8) para alternar entre Manual e Automático
    if (button5.pressed()) {
        analogWrite(leds[0], 0);
        analogWrite(leds[1], 0);
        analogWrite(leds[2], 0);
        modoAutomatico = !modoAutomatico;
        tone(3, 440, 200); // Beep diferente para troca de modo
    }

    if (modoAutomatico) {
        autocontroleTermico(); 
    } else {
        velocidade(); // Mantém seu controle manual pelos botões
    }
}

void configurarPinos() {
    int pinosEntrada[] = {A1, A2, A3, A4, 2, 7, 8};
    int pinosSaida[] = {A5, 1, 3, 4, 5, 6, 9, 10, 11, 12, 13};

    for (int pino : pinosEntrada) pinMode(pino, INPUT);
    for (int pino : pinosSaida) pinMode(pino, OUTPUT);
}

float lerTemperatura() {
    Aci_10K an10k(3.3,14);
    delayMicroseconds(500);
    return an10k.getTemp(analogRead(A1));
}

void autaTemperatura(){
    int Temp = lerTemperatura();
    if(Temp >= 30){
        analogWrite(leds[3], 255);
        tone(3, 262, 250); // Plays 262Hz tone for 0.250 seconds
        delay(100);
        analogWrite(leds[3], 0);
        noTone(3); 
        delay(100);
    }else{
         analogWrite(leds[3], 0);
        noTone(3); 
    }
}

void autocontroleTermico() {
  //t = lerTemperatura();
    
    // Calcula a velocidade (PWM: 0 a 255) baseado na temperatura (22 a 32 graus)
    // Se abaixo de 22, fanSpeedPWM = 0. Se acima de 32, fanSpeedPWM = 255.
    int pwmValue = map(constrain(t, 22, 32), 22, 32, 0, 255);
    
    // Usamos o pino 9 (leds[0]) como saída para o motor/ventilador
    analogWrite(leds[2], pwmValue);
    analogWrite(leds[0], 0);
    analogWrite(leds[1], 0); 
    
    // Feedback visual nos LEDs: quanto mais quente, mais LEDs acendem
    //digitalWrite(leds[1], (t > 25) ? HIGH : LOW);
    //digitalWrite(leds[2], (t > 29) ? HIGH : LOW);
}

void velocidade() {
    int brightness = map(lerTemperatura(), 18, 30, 100, 256);
    unsigned long currentTime = millis();
    // Define uma velocidade de transição aleatória para este ciclo.
  // A velocidade pode variar entre 2 e 6, deixando o efeito mais natural.
  int velocidade = random(2, 7);

  // Define um brilho máximo aleatório para este ciclo.
  // O brilho pode variar entre 100 e 255, criando "ondas" de diferentes intensidades.
  int brilhoMaximo = random(brightness);

    if (button2.pressed()) {
        tone(3, 262, 250); // Plays 262Hz tone for 0.250 seconds
        alterVeloc++;
        if (alterVeloc > 6) {
            alterVeloc = 1;
        }
    }
    
    // Desliga todos os LEDs e monitores de piscar antes de aplicar a nova velocidade
    analogWrite(leds[0], 0);
    analogWrite(leds[1], 0);
    analogWrite(leds[2], 0);
    
    switch (alterVeloc) {
        case 1:
            analogWrite(leds[0], 255);
            break;
        case 2:
            analogWrite(leds[1], 255);
            break;
        case 3:
            analogWrite(leds[2], 255);
            break;
        case 4:
           // --- Efeito de Acender (Fade In) ---
  // Aumenta o brilho do LED de 0 (desligado) para o brilho máximo aleatório.
  for (int brilho = 0; brilho <= brilhoMaximo; brilho++) {
    analogWrite(leds[0], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Máximo ---
  // Mantém o LED no brilho máximo por um momento.
  delay(1500); // Pausa de 1.5 segundos

  // --- Efeito de Apagar (Fade Out) ---
  // Diminui o brilho do LED do brilho máximo aleatório para 0.
  for (int brilho = brilhoMaximo; brilho >= 0; brilho--) {
    analogWrite(leds[0], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Mínimo ---
  // Mantém o LED apagado por um momento. A pausa é aleatória entre 0 e 500 milissegundos.
  delay(random(500));
            break;
        case 5:
            // --- Efeito de Acender (Fade In) ---
  // Aumenta o brilho do LED de 0 (desligado) para o brilho máximo aleatório.
  for (int brilho = 0; brilho <= brilhoMaximo; brilho++) {
    analogWrite(leds[1], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Máximo ---
  // Mantém o LED no brilho máximo por um momento.
  delay(1500); // Pausa de 1.5 segundos

  // --- Efeito de Apagar (Fade Out) ---
  // Diminui o brilho do LED do brilho máximo aleatório para 0.
  for (int brilho = brilhoMaximo; brilho >= 0; brilho--) {
    analogWrite(leds[1], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Mínimo ---
  // Mantém o LED apagado por um momento. A pausa é aleatória entre 0 e 500 milissegundos.
  delay(random(500));
            break;
        case 6:
            // --- Efeito de Acender (Fade In) ---
  // Aumenta o brilho do LED de 0 (desligado) para o brilho máximo aleatório.
  for (int brilho = 0; brilho <= brilhoMaximo; brilho++) {
    analogWrite(leds[2], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Máximo ---
  // Mantém o LED no brilho máximo por um momento.
  delay(1500); // Pausa de 1.5 segundos

  // --- Efeito de Apagar (Fade Out) ---
  // Diminui o brilho do LED do brilho máximo aleatório para 0.
  for (int brilho = brilhoMaximo; brilho >= 0; brilho--) {
    analogWrite(leds[2], brilho); // Define o brilho do LED
    delay(velocidade);           // Pequena pausa para criar o efeito suave
  }

  // --- Pausa no Brilho Mínimo ---
  // Mantém o LED apagado por um momento. A pausa é aleatória entre 0 e 500 milissegundos.
  delay(random(500));
            break;
        default:
            // Reinicia para o modo 1 se algo der errado
            alterVeloc = 1;
            break;
    }
}

void bombeamento() {
    if (button1.toggled() && button1.read() == Button::PRESSED) {
        digitalWrite(10, !digitalRead(2) && !digitalRead(10));
    } 
    value = digitalRead(2);
    if (nivelTanque != value) {
        nivelTanque = value;
        if (value == HIGH) {
            digitalWrite(13, HIGH);
            digitalWrite(10, LOW);
            Serial.println(" released");
        }
        if (value == LOW) {
            digitalWrite(13, LOW);
            Serial.println(" pressed");
        }
    }
}   

void oscilador() {
    if (button4.toggled() && button4.read() == Button::PRESSED) {
        digitalWrite(11, !digitalRead(11));
    }
}

void ionizador() {
    if (button3.toggled() && button3.read() == Button::PRESSED) {
        digitalWrite(12, !digitalRead(12));
    }
}

void atualizarDisplay() {
    static unsigned long ultimoUpdate = 0;
    if (millis() - ultimoUpdate >= 1000) {
        ultimoUpdate = millis();
        lcd.clear();
        
        // Linha 0: Temperatura e Nível de Água
        lcd.setCursor(0, 0);
        lcd.print("T:"); lcd.print(lerTemperatura(), 1); lcd.print("C");
        lcd.setCursor(10, 0);
        lcd.print(value == LOW ? "H2O:OK" : "VAZIO!");

        // Linha 1: Modo de Operação
        lcd.setCursor(0, 1);
        if (modoAutomatico) {
            //t = lerTemperatura();
            int pot = map(constrain(t, 22, 32), 22, 32, 0, 100);
            lcd.print("AUTO: "); lcd.print(pot); lcd.print("%");
        } else {
            lcd.print("MANUAL: M-"); lcd.print(alterVeloc);
        }
    }
}