Program.cs

using System;
using System.Threading;
using System.Collections.Generic;

namespace SistemaContraIncendios
{
    // ESTRUCTURA PARA ALMACENAR DATOS DEL SENSOR
    public struct DatosSensor
    {
        public int piso;
        public int habitacion;
        public double temperatura;
        public bool hayHumo;
        public DateTime fechaHora;
        public string estado;
    }

    // ESTRUCTURA PARA ALMACENAR HISTORIAL
    public struct RegistroHistorial
    {
        public DateTime fechaHora;
        public int piso;
        public int habitacion;
        public double temperatura;
        public bool hayHumo;
        public string estado;
    }

    class Program
    {
        // ARRAYS PARA ALMACENAR DATOS
        static DatosSensor[,] sensores = new DatosSensor[3, 4]; // 3 pisos, 4 habitaciones
        static RegistroHistorial[] historial = new RegistroHistorial[1000];
        static int contadorHistorial = 0;
        static bool sistemaActivo = false;
        static bool alertaActiva = false;
        static bool enMenuPrincipal = true;
        static Random random = new Random();

        static void Main(string[] args)
        {
            // INICIALIZAR SENSORES
            InicializarSensores();

            // LOGIN BÁSICO
            if (Login())
            {
                Console.Clear();
                Console.WriteLine("¡Bienvenido al Sistema Contra Incendios!");
                Thread.Sleep(2000);

                // MOSTRAR MENÚ PRINCIPAL
                MostrarMenuPrincipal();
            }
            else
            {
                Console.WriteLine("Acceso denegado. Presione cualquier tecla para salir...");
                Console.ReadKey();
            }
        }

        // FUNCIÓN DE LOGIN
        static bool Login()
        {
            int intentos = 0;

            while (intentos < 3)
            {
                Console.Clear();
                Console.WriteLine("=== SISTEMA CONTRA INCENDIOS ===");
                Console.WriteLine("Ingrese sus credenciales:");

                Console.Write("Usuario: ");
                string usuario = Console.ReadLine();

                Console.Write("Contraseña: ");
                string contraseña = Console.ReadLine();

                if (usuario == "admin" && contraseña == "1234")
                {
                    return true;
                }
                else
                {
                    intentos++;
                    Console.WriteLine($"Credenciales incorrectas. Intentos restantes: {3 - intentos}");
                    Console.WriteLine("Presione cualquier tecla para continuar...");
                    Console.ReadKey();
                }
            }

            return false;
        }

        // FUNCIÓN PARA INICIALIZAR SENSORES
        static void InicializarSensores()
        {
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    sensores[i, j].piso = i + 1;
                    sensores[i, j].habitacion = j + 1;
                    sensores[i, j].temperatura = 20.0 + random.NextDouble() * 5; // 20-25°C
                    sensores[i, j].hayHumo = false;
                    sensores[i, j].fechaHora = DateTime.Now;
                    sensores[i, j].estado = "NORMAL";
                }
            }
        }

        // FUNCIÓN PARA MOSTRAR MENÚ PRINCIPAL
        static void MostrarMenuPrincipal()
        {
            enMenuPrincipal = true;
            sistemaActivo = true;

            // Hilo para actualizar sensores en segundo plano
            Thread hiloActualizacion = new Thread(() =>
            {
                while (enMenuPrincipal)
                {
                    ActualizarSensores();
                    Thread.Sleep(2000); // Actualizar cada 2 segundos
                }
            });
            hiloActualizacion.IsBackground = true;
            hiloActualizacion.Start();

            int opcion = 0;

            do
            {
                // Verificar alerta antes de mostrar el menú
                if (VerificarAlerta() && !alertaActiva)
                {
                    alertaActiva = true;
                    enMenuPrincipal = false;
                    MostrarAlertaIncendio();
                    enMenuPrincipal = true;
                }

                if (enMenuPrincipal && !alertaActiva)
                {
                    Console.Clear();
                    Console.WriteLine("=== MENÚ PRINCIPAL ===");
                    Console.WriteLine("1. Ver historial de temperaturas");
                    Console.WriteLine("2. Probar sensor único");
                    Console.WriteLine("3. Ver estado de sensores");
                    Console.WriteLine("4. Salir");
                    Console.WriteLine();

                    // MOSTRAR MAQUETA DEL EDIFICIO CON DATOS ACTUALIZADOS
                    MostrarMaquetaEdificio();

                    // Mostrar estado actual
                    MostrarEstadoActual();

                    Console.Write("Seleccione una opción: ");

                    // Verificar si hay entrada disponible
                    if (Console.KeyAvailable)
                    {
                        string input = Console.ReadLine();
                        if (int.TryParse(input, out opcion))
                        {
                            switch (opcion)
                            {
                                case 1:
                                    enMenuPrincipal = false;
                                    VerHistorialTemperaturas();
                                    enMenuPrincipal = true;
                                    break;
                                case 2:
                                    enMenuPrincipal = false;
                                    ProbarSensorUnico();
                                    enMenuPrincipal = true;
                                    break;
                                case 3:
                                    enMenuPrincipal = false;
                                    VerEstadoSensores();
                                    enMenuPrincipal = true;
                                    break;
                                case 4:
                                    Console.WriteLine("Saliendo del sistema...");
                                    sistemaActivo = false;
                                    enMenuPrincipal = false;
                                    break;
                                default:
                                    Console.WriteLine("Opción inválida. Presione cualquier tecla...");
                                    Console.ReadKey();
                                    break;
                            }
                        }
                        else
                        {
                            Console.WriteLine("Entrada inválida. Presione cualquier tecla...");
                            Console.ReadKey();
                        }
                    }
                    else
                    {
                        // Si no hay entrada, actualizar la pantalla cada segundo
                        Thread.Sleep(1000);
                    }
                }

            } while (opcion != 4 && enMenuPrincipal);
        }

        // FUNCIÓN PARA MOSTRAR MAQUETA DEL EDIFICIO
        static void MostrarMaquetaEdificio()
        {
            Console.WriteLine("\n=== MAQUETA DEL EDIFICIO ===");
            Console.WriteLine($"Última actualización: {DateTime.Now:HH:mm:ss}");

            for (int piso = 2; piso >= 0; piso--) // Mostrar de arriba hacia abajo
            {
                Console.Write($"Piso {piso + 1}: ");

                for (int habitacion = 0; habitacion < 4; habitacion++)
                {
                    string color = ObtenerColorSensor(piso, habitacion);

                    // ESTRUCTURAS CONDICIONALES MÚLTIPLES
                    if (color == "VERDE")
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.Write("[OK] ");
                    }
                    else if (color == "AMARILLO")
                    {
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.Write("[⚠] ");
                    }
                    else if (color == "ROJO")
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write("[🔥] ");
                    }

                    Console.ResetColor();
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        // FUNCIÓN PARA OBTENER COLOR DEL SENSOR
        static string ObtenerColorSensor(int piso, int habitacion)
        {
            double temp = sensores[piso, habitacion].temperatura;
            bool humo = sensores[piso, habitacion].hayHumo;

            // ESTRUCTURAS CONDICIONALES ANIDADAS
            if (temp > 30.0) // Temperatura inestable
            {
                if (humo)
                {
                    return "ROJO"; // Humo + temperatura alta
                }
                else
                {
                    return "AMARILLO"; // Solo temperatura alta
                }
            }
            else // Temperatura estable
            {
                if (humo)
                {
                    return "AMARILLO"; // Solo humo
                }
                else
                {
                    return "VERDE"; // Todo normal
                }
            }
        }

        // FUNCIÓN PARA VER ESTADO DE SENSORES
        static void VerEstadoSensores()
        {
            bool monitoreoActivo = true;
            alertaActiva = false;

            Console.Clear();
            Console.WriteLine("=== MONITOREO EN TIEMPO REAL ===");
            Console.WriteLine("Presione ESC para volver al menú principal\n");

            while (monitoreoActivo)
            {
                if (Console.KeyAvailable)
                {
                    ConsoleKeyInfo key = Console.ReadKey(true);
                    if (key.Key == ConsoleKey.Escape)
                    {
                        monitoreoActivo = false;
                        break;
                    }
                }

                // Actualizar sensores cada 2 segundos
                ActualizarSensores();

                // Verificar si hay alerta
                if (VerificarAlerta() && !alertaActiva)
                {
                    alertaActiva = true;
                    MostrarAlertaIncendioEnMonitoreo();
                    alertaActiva = false;
                }

                if (!alertaActiva)
                {
                    Console.Clear();
                    Console.WriteLine("=== MONITOREO EN TIEMPO REAL ===");
                    Console.WriteLine("Presione ESC para volver al menú principal\n");

                    // Mostrar estado actual
                    MostrarEstadoActual();
                    MostrarMaquetaEdificio();

                    // Sonido de actualización
                    Console.Beep(800, 100);

                    Thread.Sleep(2000);
                }
            }
        }

        // FUNCIÓN PARA ACTUALIZAR SENSORES
        static void ActualizarSensores()
        {
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    // Generar temperatura aleatoria
                    double nuevaTemp = 18.0 + random.NextDouble() * 20; // 18-38°C

                    // Generar humo aleatorio (10% probabilidad)
                    bool nuevoHumo = random.NextDouble() < 0.1;

                    sensores[i, j].temperatura = nuevaTemp;
                    sensores[i, j].hayHumo = nuevoHumo;
                    sensores[i, j].fechaHora = DateTime.Now;

                    // Actualizar estado
                    ActualizarEstadoSensor(i, j);

                    // Guardar en historial
                    GuardarEnHistorial(i, j);
                }
            }
        }

        // FUNCIÓN PARA ACTUALIZAR ESTADO DEL SENSOR
        static void ActualizarEstadoSensor(int piso, int habitacion)
        {
            double temp = sensores[piso, habitacion].temperatura;
            bool humo = sensores[piso, habitacion].hayHumo;

            if (temp > 30.0 && humo)
            {
                sensores[piso, habitacion].estado = "EMERGENCIA";
            }
            else if (temp > 30.0 || humo)
            {
                sensores[piso, habitacion].estado = "ALERTA";
            }
            else
            {
                sensores[piso, habitacion].estado = "NORMAL";
            }
        }

        // FUNCIÓN PARA GUARDAR EN HISTORIAL
        static void GuardarEnHistorial(int piso, int habitacion)
        {
            if (contadorHistorial < 1000)
            {
                historial[contadorHistorial].fechaHora = sensores[piso, habitacion].fechaHora;
                historial[contadorHistorial].piso = piso + 1;
                historial[contadorHistorial].habitacion = habitacion + 1;
                historial[contadorHistorial].temperatura = sensores[piso, habitacion].temperatura;
                historial[contadorHistorial].hayHumo = sensores[piso, habitacion].hayHumo;
                historial[contadorHistorial].estado = sensores[piso, habitacion].estado;
                contadorHistorial++;
            }
        }

        // FUNCIÓN PARA VERIFICAR ALERTA
        static bool VerificarAlerta()
        {
            // ESTRUCTURA REPETITIVA PARA (FOR) ANIDADA
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    if (sensores[i, j].temperatura > 30.0 && sensores[i, j].hayHumo)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        // FUNCIÓN PARA MOSTRAR ALERTA DE INCENDIO DESDE MENÚ PRINCIPAL
        static void MostrarAlertaIncendio()
        {
            bool alertaEnCurso = true;

            while (alertaEnCurso)
            {
                Console.Clear();

                // Mostrar alerta en rojo
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨");
                Console.WriteLine("🔥 SEÑALES DE INCENDIO DETECTADAS 🔥");
                Console.WriteLine("🚨 CONTACTANDO CON LOS BOMBEROS 🚨");
                Console.WriteLine("🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨");
                Console.ResetColor();

                Console.WriteLine("\nPresione 1 para simular agua y extintor");
                Console.WriteLine("Presione ESC para volver al menú");

                // Mostrar sensores en emergencia
                MostrarSensoresEmergencia();

                // Sonido de alerta
                Console.Beep(1000, 300);
                Console.Beep(800, 300);

                DateTime inicio = DateTime.Now;
                bool entradaDetectada = false;

                while ((DateTime.Now - inicio).TotalMilliseconds < 1000 && !entradaDetectada)
                {
                    if (Console.KeyAvailable)
                    {
                        ConsoleKeyInfo key = Console.ReadKey(true);
                        entradaDetectada = true;

                        if (key.Key == ConsoleKey.D1)
                        {
                            ExtinguirIncendio();
                            alertaEnCurso = false;
                            alertaActiva = false;
                        }
                        else if (key.Key == ConsoleKey.Escape)
                        {
                            alertaEnCurso = false;
                            alertaActiva = false;
                        }
                    }
                    Thread.Sleep(50);
                }

                // Verificar si la alerta sigue activa
                if (!VerificarAlerta())
                {
                    alertaEnCurso = false;
                    alertaActiva = false;
                }
            }
        }

        // FUNCIÓN PARA MOSTRAR ALERTA DE INCENDIO EN MONITOREO
        static void MostrarAlertaIncendioEnMonitoreo()
        {
            bool alertaEnCurso = true;

            while (alertaEnCurso)
            {
                Console.Clear();

                // Mostrar alerta en rojo
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨");
                Console.WriteLine("🔥 SEÑALES DE INCENDIO DETECTADAS 🔥");
                Console.WriteLine("🚨 CONTACTANDO CON LOS BOMBEROS 🚨");
                Console.WriteLine("🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨");
                Console.ResetColor();

                Console.WriteLine("\nPresione 1 para simular agua y extintor");
                Console.WriteLine("Presione cualquier otra tecla para continuar");

                // Mostrar sensores en emergencia
                MostrarSensoresEmergencia();

                // Sonido de alerta
                Console.Beep(1000, 300);
                Console.Beep(800, 300);

                // Esperar por entrada del usuario con timeout
                DateTime inicio = DateTime.Now;
                bool entradaDetectada = false;

                while ((DateTime.Now - inicio).TotalMilliseconds < 1000 && !entradaDetectada)
                {
                    if (Console.KeyAvailable)
                    {
                        ConsoleKeyInfo key = Console.ReadKey(true);
                        entradaDetectada = true;

                        if (key.Key == ConsoleKey.D1)
                        {
                            ExtinguirIncendio();
                            alertaEnCurso = false;
                        }
                        else
                        {
                            alertaEnCurso = false;
                        }
                    }
                    Thread.Sleep(50);
                }

                // Verificar si la alerta sigue activa
                if (!VerificarAlerta())
                {
                    alertaEnCurso = false;
                }
            }
        }

        // FUNCIÓN PARA MOSTRAR SENSORES EN EMERGENCIA
        static void MostrarSensoresEmergencia()
        {
            Console.WriteLine("\n=== SENSORES EN EMERGENCIA ===");

            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    if (sensores[i, j].estado == "EMERGENCIA")
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine($"🔥 Piso {i + 1}, Habitación {j + 1}: {sensores[i, j].temperatura:F1}°C - HUMO DETECTADO");
                        Console.ResetColor();
                    }
                }
            }
        }

        // FUNCIÓN PARA EXTINGUIR INCENDIO
        static void ExtinguirIncendio()
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine("💧 ACTIVANDO SISTEMA DE EXTINCIÓN 💧");
            Console.WriteLine("🧯 ROCIADORES ACTIVADOS 🧯");
            Console.ResetColor();

            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    if (sensores[i, j].estado == "EMERGENCIA")
                    {
                        sensores[i, j].temperatura = 20.0 + random.NextDouble() * 5;
                        sensores[i, j].hayHumo = false;
                        sensores[i, j].estado = "NORMAL";
                        sensores[i, j].fechaHora = DateTime.Now;
                        GuardarEnHistorial(i, j);
                    }
                }
            }

            Console.WriteLine("\n✅ INCENDIO EXTINGUIDO EXITOSAMENTE");
            Console.WriteLine("🔄 SISTEMA REGULARIZADO");
            Console.WriteLine("\nPresione cualquier tecla para continuar...");
            Console.ReadKey();
        }

        // FUNCIÓN PARA MOSTRAR ESTADO ACTUAL
        static void MostrarEstadoActual()
        {
            Console.WriteLine($"Última actualización: {DateTime.Now:HH:mm:ss}");
            Console.WriteLine("Estado de sensores por piso:");

            // ESTRUCTURA REPETITIVA PARA (FOR) ANIDADA
            for (int i = 0; i < 3; i++)
            {
                Console.Write($"Piso {i + 1}: ");
                for (int j = 0; j < 4; j++)
                {
                    Console.Write($"H{j + 1}({sensores[i, j].temperatura:F1}°C");
                    if (sensores[i, j].hayHumo) Console.Write("💨");
                    Console.Write(") ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        // FUNCIÓN PARA PROBAR SENSOR ÚNICO
        static void ProbarSensorUnico()
        {
            Console.Clear();
            Console.WriteLine("=== PRUEBA DE SENSOR ÚNICO ===");

            Console.Write("Ingrese el piso (1-3): ");
            int piso = int.Parse(Console.ReadLine()) - 1;

            Console.Write("Ingrese la habitación (1-4): ");
            int habitacion = int.Parse(Console.ReadLine()) - 1;

            // ESTRUCTURAS CONDICIONALES ANIDADAS
            if (piso >= 0 && piso < 3 && habitacion >= 0 && habitacion < 4)
            {
                Console.WriteLine($"\nProbando sensor Piso {piso + 1}, Habitación {habitacion + 1}...");

                // ESTRUCTURA REPETITIVA PARA (FOR)
                for (int i = 0; i < 10; i++)
                {
                    // Generar datos aleatorios para la prueba
                    double tempPrueba = 15.0 + random.NextDouble() * 25;
                    bool humoPrueba = random.NextDouble() < 0.2;

                    Console.Clear();
                    Console.WriteLine("=== PRUEBA DE SENSOR ÚNICO ===");
                    Console.WriteLine($"Sensor: Piso {piso + 1}, Habitación {habitacion + 1}");
                    Console.WriteLine($"Lectura {i + 1}/10");
                    Console.WriteLine($"Temperatura: {tempPrueba:F1}°C");
                    Console.WriteLine($"Humo: {(humoPrueba ? "DETECTADO" : "NO DETECTADO")}");

                    // Determinar estado
                    string estadoPrueba = "NORMAL";
                    ConsoleColor color = ConsoleColor.Green;

                    if (tempPrueba > 30.0 && humoPrueba)
                    {
                        estadoPrueba = "EMERGENCIA";
                        color = ConsoleColor.Red;
                    }
                    else if (tempPrueba > 30.0 || humoPrueba)
                    {
                        estadoPrueba = "ALERTA";
                        color = ConsoleColor.Yellow;
                    }

                    Console.ForegroundColor = color;
                    Console.WriteLine($"Estado: {estadoPrueba}");
                    Console.ResetColor();

                    Console.Beep(600, 100);
                    Thread.Sleep(1000);
                }

                Console.WriteLine("\nPrueba completada. Presione cualquier tecla...");
                Console.ReadKey();
            }
            else
            {
                Console.WriteLine("Ubicación inválida. Presione cualquier tecla...");
                Console.ReadKey();
            }
        }

        // FUNCIÓN PARA VER HISTORIAL DE TEMPERATURAS
        static void VerHistorialTemperaturas()
        {
            Console.Clear();
            Console.WriteLine("=== HISTORIAL DE TEMPERATURAS ===");

            if (contadorHistorial == 0)
            {
                Console.WriteLine("No hay registros en el historial.");
            }
            else
            {
                Console.WriteLine($"Mostrando {contadorHistorial} registros:\n");
                Console.WriteLine("Fecha/Hora\t\tPiso\tHab\tTemp\tHumo\tEstado");
                Console.WriteLine("================================================================");

                // ESTRUCTURA REPETITIVA PARA (FOR)
                for (int i = 0; i < contadorHistorial; i++)
                {
                    Console.WriteLine($"{historial[i].fechaHora:MM/dd HH:mm:ss}\t{historial[i].piso}\t{historial[i].habitacion}\t{historial[i].temperatura:F1}°C\t{(historial[i].hayHumo ? "SÍ" : "NO")}\t{historial[i].estado}");

                    // Mostrar de 20 en 20
                    if ((i + 1) % 20 == 0)
                    {
                        Console.WriteLine("\nPresione cualquier tecla para continuar...");
                        Console.ReadKey();
                        Console.Clear();
                        Console.WriteLine("=== HISTORIAL DE TEMPERATURAS (continuación) ===");
                        Console.WriteLine("Fecha/Hora\t\tPiso\tHab\tTemp\tHumo\tEstado");
                        Console.WriteLine("================================================================");
                    }
                }
            }

            Console.WriteLine("\nPresione cualquier tecla para volver al menú...");
            Console.ReadKey();
        }
    }
}