// ===== CONFIGURAÇÕES AJUSTÁVEIS =====
// Defina aqui os valores que deseja ajustar

// Pinos dos componentes
const int TRIG_PIN = 12;
const int ECHO_PIN = 11;
const int GREEN_LED = 6;
const int YELLOW_LED = 5;
const int RED_LED = 3;
const int BUZZER_PIN = 10;

// Distâncias de ativação (em centímetros)
const int DISTANCIA_INICIAL = 50;    // 50cm = 500mm (meio metro)
const int DISTANCIA_AMARELO = 15;    // 15cm = 150mm
const int DISTANCIA_VERMELHO = 7;    // 7cm = 70mm

// Tempos e intervalos (em milissegundos)
const int TEMPO_DE_ATIVACAO = 7000;  // 7 segundos
const int INTERVALO_VERDE = 500;     // Piscar do LED verde
const int INTERVALO_AMARELO = 300;   // Piscar do LED amarelo
const int INTERVALO_VERMELHO = 150;  // Piscar rápido quando perto
const int INTERVALO_MEDICAO = 100;   // Intervalo entre medições

// Tons do buzzer (em Hz)
const int TOM_VERDE = 700;
const int TOM_AMARELO = 800;
const int TOM_VERMELHO = 1000;

// ===== FIM DAS CONFIGURAÇÕES =====

// Variáveis globais
double distanciaCM = 0;
unsigned long tempoAmareloAtivado = 0;
unsigned long ultimoTempoVerde = 0;
unsigned long ultimoTempoAmarelo = 0;
unsigned long ultimoTempoVermelho = 0;
bool sistemaAtivo = false;
bool amareloAtivo = false;
bool sistemaTimeout = false;
bool objetoPresenteTimeout = false;

// Função para ler distância do sensor ultrassônico
long lerDistanciaUltrassonica(int pinoTrigger, int pinoEcho) {
  pinMode(pinoTrigger, OUTPUT);
  digitalWrite(pinoTrigger, LOW);
  delayMicroseconds(2);
  digitalWrite(pinoTrigger, HIGH);
  delayMicroseconds(10);
  digitalWrite(pinoTrigger, LOW);
  pinMode(pinoEcho, INPUT);
  return pulseIn(pinoEcho, HIGH);
}

// Função para calcular a distância
void calcularDistancia() {
  distanciaCM = 0.01723 * lerDistanciaUltrassonica(TRIG_PIN, ECHO_PIN);
}

// Função para desligar todos os componentes
void desligarTudo() {
  digitalWrite(GREEN_LED, LOW);
  digitalWrite(YELLOW_LED, LOW);
  digitalWrite(RED_LED, LOW);
  noTone(BUZZER_PIN);
}

// Função para reiniciar o sistema
void reiniciarSistema() {
  sistemaAtivo = false;
  amareloAtivo = false;
  sistemaTimeout = false;
  objetoPresenteTimeout = false;
  desligarTudo();
  Serial.println("Sistema reiniciado - Pronto para nova detecção");
}

void setup() {
  Serial.begin(115200);
  
  // Configura os pinos
  pinMode(GREEN_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  
  Serial.println("Sistema de Alerta por Distância Iniciado");
  Serial.println("========================================");
  Serial.println("Timer de 7s será acionado apenas quando o amarelo ativar");
}

void loop() {
  calcularDistancia();
  
  // Verifica se o sistema está em timeout
  if (sistemaTimeout) {
    // Se há um objeto presente durante o timeout, marca como presente
    if (distanciaCM <= DISTANCIA_INICIAL && distanciaCM > 0) {
      objetoPresenteTimeout = true;
      
      // Se o objeto está na zona vermelha durante o timeout, ativa alerta máximo
      if (distanciaCM <= DISTANCIA_VERMELHO) {
        // Piscar todos os LEDs rapidamente e buzzer
        if (millis() - ultimoTempoVermelho >= INTERVALO_VERMELHO) {
          bool estado = !digitalRead(RED_LED);
          digitalWrite(GREEN_LED, estado);
          digitalWrite(YELLOW_LED, estado);
          digitalWrite(RED_LED, estado);
          ultimoTempoVermelho = millis();
          
          // Alternar o buzzer
          if (estado) {
            tone(BUZZER_PIN, TOM_VERMELHO);
          } else {
            noTone(BUZZER_PIN);
          }
        }
        return;
      }
    }
    // Se o objeto foi removido após o timeout, reinicia o sistema
    else if (objetoPresenteTimeout && (distanciaCM > DISTANCIA_INICIAL || distanciaCM <= 0)) {
      reiniciarSistema();
    }
    
    // Mantém tudo desligado durante o timeout
    desligarTudo();
    delay(INTERVALO_MEDICAO);
    return;
  }
  
  // Verifica se há um objeto na distância inicial
  if (distanciaCM <= DISTANCIA_INICIAL && distanciaCM > 0 && !sistemaAtivo) {
    sistemaAtivo = true;
    amareloAtivo = false;
    Serial.println("Sistema ativado - Objeto detectado");
  }
  
  // Se não há objeto, reseta o sistema
  if (distanciaCM > DISTANCIA_INICIAL || distanciaCM <= 0) {
    if (sistemaAtivo) {
      Serial.println("Sistema resetado - Objeto removido");
    }
    reiniciarSistema();
    delay(INTERVALO_MEDICAO);
    return;
  }
  
  // Controla os estágios baseado na distância
  if (sistemaAtivo) {
    // Verifica se o amarelo está ativo e se passaram 7 segundos
    if (amareloAtivo && millis() - tempoAmareloAtivado >= TEMPO_DE_ATIVACAO) {
      sistemaTimeout = true;
      objetoPresenteTimeout = (distanciaCM <= DISTANCIA_INICIAL && distanciaCM > 0);
      Serial.println("Timeout de 7 segundos - Sistema em pausa");
      Serial.println("Remova o objeto para reiniciar o sistema");
      delay(INTERVALO_MEDICAO);
      return;
    }
    
    // Exibe informações no serial
    Serial.print("Distância: ");
    Serial.print(distanciaCM);
    if (amareloAtivo) {
      Serial.print(" cm | Tempo restante: ");
      Serial.print((TEMPO_DE_ATIVACAO - (millis() - tempoAmareloAtivado)) / 1000);
      Serial.println(" segundos");
    } else {
      Serial.println(" cm");
    }
    
    // Estágio 1: LED verde piscando (acima de 150mm)
    if (distanciaCM > DISTANCIA_AMARELO) {
      digitalWrite(YELLOW_LED, LOW);
      digitalWrite(RED_LED, LOW);
      
      // Piscar o LED verde
      if (millis() - ultimoTempoVerde >= INTERVALO_VERDE) {
        digitalWrite(GREEN_LED, !digitalRead(GREEN_LED));
        ultimoTempoVerde = millis();
      }
      noTone(BUZZER_PIN);
    }
    // Estágio 2: LED amarelo piscando e buzzer (150mm ou menos)
    else if (distanciaCM <= DISTANCIA_AMARELO && distanciaCM > DISTANCIA_VERMELHO) {
      digitalWrite(GREEN_LED, LOW);
      digitalWrite(RED_LED, LOW);
      
      // Ativa o timer apenas quando o amarelo é ativado pela primeira vez
      if (!amareloAtivo) {
        amareloAtivo = true;
        tempoAmareloAtivado = millis();
        Serial.println("Zona de alerta amarelo ativada - Timer de 7s iniciado");
      }
      
      // Piscar o LED amarelo e acionar buzzer
      if (millis() - ultimoTempoAmarelo >= INTERVALO_AMARELO) {
        digitalWrite(YELLOW_LED, !digitalRead(YELLOW_LED));
        ultimoTempoAmarelo = millis();
        
        // Alternar o buzzer
        if (digitalRead(YELLOW_LED)) {
          tone(BUZZER_PIN, TOM_AMARELO);
        } else {
          noTone(BUZZER_PIN);
        }
      }
    }
    // Estágio 3: Todos os LEDs piscando rapidamente e buzzer (70mm ou menos)
    else if (distanciaCM <= DISTANCIA_VERMELHO) {
      // Ativa o timer se ainda não foi ativado (objeto passou direto para vermelho)
      if (!amareloAtivo) {
        amareloAtivo = true;
        tempoAmareloAtivado = millis();
        Serial.println("Zona de alerta vermelha ativada - Timer de 7s iniciado");
      }
      
      // Piscar todos os LEDs rapidamente e buzzer
      if (millis() - ultimoTempoVermelho >= INTERVALO_VERMELHO) {
        bool estado = !digitalRead(RED_LED);
        digitalWrite(GREEN_LED, estado);
        digitalWrite(YELLOW_LED, estado);
        digitalWrite(RED_LED, estado);
        ultimoTempoVermelho = millis();
        
        // Alternar o buzzer
        if (estado) {
          tone(BUZZER_PIN, TOM_VERMELHO);
        } else {
          noTone(BUZZER_PIN);
        }
        
        Serial.println("ALERTA VERMELHO - Distância crítica!");
      }
    }
  }
  
  delay(INTERVALO_MEDICAO);
}