#include <Wire.h>
#include <LiquidCrystal.h>
#include <Keypad.h>
#include <NewPing.h> // Biblioteca para el sensor ultrasónico

// Definición de pines para el LCD, el Keypad y el buzzer
LiquidCrystal lcd(16, 17, 15, 2, 0, 21); // Pines RS, E, D4, D5, D6, D7
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {32, 33, 25, 26}; // Filas conectadas a estos pines
byte colPins[COLS] = {27, 14, 12, 13}; // Columnas conectadas a estos pines
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// Definición de pines para los sensores
#define LDR_AO_PIN 36 // Usando VP (GPIO36) para el LDR

#define EXT_ULTRASONIC_TRIG_PIN 5
#define EXT_ULTRASONIC_ECHO_PIN 4
#define EXT_MOTION_PIN 35

#define INT_ULTRASONIC_TRIG_PIN 18
#define INT_ULTRASONIC_ECHO_PIN 19
#define INT_MOTION_PIN 23

// Pin para el buzzer
#define BUZZER_PIN 22

// Variables para el estado de la alarma y la contraseña
bool alarmActivated = false;
bool passwordEntered = false;
String enteredPassword = "";

// Variables para el temporizador
unsigned long activationStartTime = 0;
unsigned long deactivationStartTime = 0;
const unsigned long activationDuration = 10000; // Duración de activación en milisegundos (10 segundos)
const unsigned long deactivationDuration = 10000; // Duración de desactivación en milisegundos (10 segundos)
unsigned long lastPasswordTime = 0; // Última vez que se ingresó la clave correctamente
const unsigned long passwordInterval = 60000; // Intervalo para pedir la clave nuevamente (1 minuto)

// Frecuencia del tono del buzzer
const int buzzerFrequency = 1000; // Frecuencia en Hertz (1000 Hz)

// Variables para controlar la visualización del estado de la alarma
bool displayActivationMessage = false;
bool displayDeactivationMessage = false;

// Variables para controlar el estado anterior de la luminosidad
int previousLuminosity = 0;

// Variable para indicar si el LDR está activo (detecta menos de 100 lux)
bool ldrActive = false;

void setup() {
  Serial.begin(9600);

  // Inicialización del LCD
  lcd.begin(16, 2);
  lcd.clear();
  lcd.print("Ingrese clave:");

  // Inicialización de los pines de los sensores
  pinMode(EXT_ULTRASONIC_TRIG_PIN, OUTPUT);
  pinMode(EXT_ULTRASONIC_ECHO_PIN, INPUT);
  pinMode(EXT_MOTION_PIN, INPUT);
  pinMode(INT_ULTRASONIC_TRIG_PIN, OUTPUT);
  pinMode(INT_ULTRASONIC_ECHO_PIN, INPUT);
  pinMode(INT_MOTION_PIN, INPUT);
  
  // Inicialización del pin del LDR
  pinMode(LDR_AO_PIN, INPUT);

  // Inicialización del pin del buzzer
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  char key = keypad.getKey();
  
  if (key != NO_KEY) {
    if (!passwordEntered) {
      if (key != '#') {
        // Solo agrega el dígito si aún no se ha alcanzado la longitud máxima de la contraseña
        if (enteredPassword.length() < 4) {
          enteredPassword += key;
          lcd.setCursor(enteredPassword.length() - 1, 1);
          lcd.print("*");
        }
      } else {
        // Verifica la contraseña ingresada
        if (enteredPassword == "1434") { // Asegúrate de que la contraseña esté entre comillas y no tenga espacios adicionales
          passwordEntered = true;
          lastPasswordTime = millis(); // Registra el tiempo de ingreso de la contraseña
          lcd.clear();
          lcd.print("Clave correcta");
          delay(1000);
          lcd.clear();
          lcd.print("Seleccione:");
          lcd.setCursor(0, 1);
          lcd.print("A: Activar");
          lcd.setCursor(8, 1);
          lcd.print("D: Desactivar");
        } else {
          lcd.clear();
          lcd.print("Clave incorrecta");
          delay(1000);
          lcd.clear();
          lcd.print("Ingrese clave:");
          enteredPassword = "";
        }
      }
    } else {
      if (key == 'A') {
        alarmActivated = true;
        activationStartTime = millis(); // Registra el tiempo de inicio de activación
        displayActivationMessage = true;
        lcd.clear();
        lcd.print("Activando en:");
        lcd.setCursor(0, 1);
        lcd.print("10 s");
      } else if (key == 'D') {
        alarmActivated = false;
        deactivationStartTime = millis(); // Registra el tiempo de inicio de desactivación
        displayDeactivationMessage = true;
        lcd.clear();
        lcd.print("Desactivando en:");
        lcd.setCursor(0, 1);
        lcd.print("10 s");
      }
    }
  }

  // Lógica de la alarma
  if (passwordEntered) {
    // Verifica si ha pasado el intervalo de tiempo para pedir la clave nuevamente
    if (millis() - lastPasswordTime > passwordInterval) {
      passwordEntered = false;
      lcd.clear();
      lcd.print("Ingrese clave:");
      enteredPassword = "";
    } else {
      if (alarmActivated) {
        // Verifica si la activación ha alcanzado su duración
        if (millis() - activationStartTime < activationDuration) {
          // Muestra el tiempo restante en el LCD
          int secondsLeft = (activationDuration - (millis() - activationStartTime)) / 1000;
          lcd.setCursor(0, 1);
          lcd.print(secondsLeft);
          lcd.print(" s ");
        } else if (displayActivationMessage) {
          // Muestra que la alarma está activada solo una vez
          lcd.clear();
          lcd.print("Alarma activada");
          delay(1000);
          lcd.clear();
          lcd.print("Seleccione:");
          lcd.setCursor(0, 1);
          lcd.print("A: Activar");
          lcd.setCursor(8, 1);
          lcd.print("D: Desactivar");
          displayActivationMessage = false;
        }

        // Verifica la luminosidad en tiempo real para activar/desactivar el buzzer
        int luminosity = analogRead(LDR_AO_PIN);

        if (luminosity < 500) {
          // Si la luminosidad es menor a 100 lux, activa una acción (por ejemplo, activar el buzzer)
          if (!ldrActive) {
            ldrActive = true;
          }
        } else {
          // Si la luminosidad es igual o mayor a 100 lux
          ldrActive = false; // Reinicia el estado del LDR activo
        }

        // Verifica la distancia de los sensores ultrasónicos para activar el buzzer
        int extDistance = readUltrasonic(EXT_ULTRASONIC_TRIG_PIN, EXT_ULTRASONIC_ECHO_PIN);
        int intDistance = readUltrasonic(INT_ULTRASONIC_TRIG_PIN, INT_ULTRASONIC_ECHO_PIN);
        
        Serial.print("Distancia ext: ");
        Serial.println(extDistance);
        Serial.print("Distancia int: ");
        Serial.println(intDistance);
        
        // Verifica las condiciones de los sensores para activar el buzzer
        if (extDistance < 400 || intDistance < 400 || digitalRead(EXT_MOTION_PIN) == HIGH || digitalRead(INT_MOTION_PIN) == HIGH) {
          tone(BUZZER_PIN, buzzerFrequency);
        } else {
          noTone(BUZZER_PIN);
        }
      } else {
        // Verifica si la desactivación ha alcanzado su duración
        if (millis() - deactivationStartTime < deactivationDuration) {
          // Muestra el tiempo restante en el LCD
          int secondsLeft = (deactivationDuration - (millis() - deactivationStartTime)) / 1000;
          lcd.setCursor(0, 1);
          lcd.print(secondsLeft);
          lcd.print(" s ");
        } else if (displayDeactivationMessage) {
          // Muestra que la alarma está desactivada solo una vez
          lcd.clear();
          lcd.print("Alarma desactivada");
          delay(1000);
          lcd.clear();
          lcd.print("Seleccione:");
          lcd.setCursor(0, 1);
          lcd.print("A: Activar");
          lcd.setCursor(8, 1);
          lcd.print("D: Desactivar");
          displayDeactivationMessage = false;
        }
        
        // Apaga el buzzer si la alarma está desactivada
        noTone(BUZZER_PIN);
      }
    }
  }

  delay(100);
}

// Función para leer la distancia del sensor ultrasónico
int readUltrasonic(int trigPin, int echoPin) {
  NewPing sonar(trigPin, echoPin, 400); // Configuración de NewPing para pines y distancia máxima

  delay(50); // Espera de 50ms entre pings (aproximadamente 20 pings/segundo)
  return sonar.ping_cm(); // Envía ping, obtén distancia en centímetros
}