Colas.java

// Importación de librerías necesarias
import javax.swing.*;  // Para la interfaz gráfica
import java.awt.*;    // Para componentes adicionales de GUI
import java.util.LinkedList;  // Para implementar la cola
import java.util.Queue;       // Interface para la cola
import java.util.Scanner;     // Para entrada de datos por consola
import java.time.LocalDateTime;  // Para manejar fechas y horas
import java.time.format.DateTimeFormatter;  // Para formatear fechas

// Clase para crear la ventana que muestra la cola de impresión
class VentanaCola extends JFrame {
    private JTextArea areaTexto;  // Área donde se mostrará la información
    private Timer timer;          // Temporizador para actualizar la ventana

    public VentanaCola() {
        // Configuración básica de la ventana
        setTitle("Cola de Impresión");
        setSize(500, 400);
        setLocationRelativeTo(null);  // Centra la ventana en la pantalla
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  // Comportamiento al cerrar

        // Configuración del área de texto
        areaTexto = new JTextArea();
        areaTexto.setEditable(false);  // Evita que el usuario modifique el texto
        areaTexto.setFont(new Font("Monospaced", Font.PLAIN, 12));
        
        // Agregar barra de desplazamiento al área de texto
        JScrollPane scrollPane = new JScrollPane(areaTexto);
        add(scrollPane);

        // Configurar temporizador para actualizar cada segundo
        timer = new Timer(1000, e -> this.repaint());
        timer.start();
    }

    // Método para actualizar el contenido de la ventana
    public void actualizarCola(String informacion) {
        areaTexto.setText(informacion);
    }

    // Sobrescribir el método dispose para detener el timer al cerrar
    @Override
    public void dispose() {
        timer.stop();
        super.dispose();
    }
}

// Clase para representar un documento a imprimir
class Documento {
    private String nombre;
    private String tipo;
    private int numPaginas;
    private String computadoraOrigen;
    private LocalDateTime horaEntrada;
    private int tiempoEstimado;
    private int paginasImpresas;
    private boolean enImpresion;

    // Constructor del documento
    public Documento(String nombre, String tipo, int numPaginas, String computadoraOrigen) {
        this.nombre = nombre;
        this.tipo = tipo;
        this.numPaginas = numPaginas;
        this.computadoraOrigen = computadoraOrigen;
        this.horaEntrada = LocalDateTime.now();
        this.paginasImpresas = 0;
        this.enImpresion = false;
        calcularTiempoEstimado();
    }

    // Calcula el tiempo estimado según el tipo de documento
    private void calcularTiempoEstimado() {
        switch (tipo) {
            case "Texto": tiempoEstimado = numPaginas * 2; break;
            case "Imagen": tiempoEstimado = numPaginas * 4; break;
            case "PDF": tiempoEstimado = numPaginas * 3; break;
            case "Presentación": tiempoEstimado = numPaginas * 5; break;
        }
    }

    // Métodos getter y setter
    public String getNombre() { return nombre; }
    public String getTipo() { return tipo; }
    public int getNumPaginas() { return numPaginas; }
    public String getComputadoraOrigen() { return computadoraOrigen; }
    public LocalDateTime getHoraEntrada() { return horaEntrada; }
    public int getTiempoEstimado() { return tiempoEstimado; }
    public int getPaginasImpresas() { return paginasImpresas; }
    public void setPaginasImpresas(int paginas) { this.paginasImpresas = paginas; }
    public boolean isEnImpresion() { return enImpresion; }
    public void setEnImpresion(boolean enImpresion) { this.enImpresion = enImpresion; }
}

// Clase principal que maneja la impresora
class ImpresoraRed {
    private Queue<Documento> colaImpresion;  // Cola de documentos
    private String estado;                   // Estado actual de la impresora
    private int documentosImpresos;          // Contador de documentos impresos
    private Thread hiloImpresion;            // Hilo para proceso de impresión
    private boolean imprimiendo;             // Bandera de estado de impresión
    private DateTimeFormatter formatoHora;    // Formateador de hora
    private VentanaCola ventanaCola;         // Ventana para mostrar la cola
    private Documento documentoActual;        // Documento en impresión actual

    // Constructor de la impresora
    public ImpresoraRed() {
        this.colaImpresion = new LinkedList<>();
        this.estado = "Disponible";
        this.documentosImpresos = 0;
        this.imprimiendo = false;
        this.formatoHora = DateTimeFormatter.ofPattern("HH:mm:ss");
        this.ventanaCola = new VentanaCola();
    }

    // Método para agregar un documento a la cola
    public synchronized void agregarDocumento(Documento documento) {
        colaImpresion.offer(documento);
        System.out.println("\nDocumento agregado a la cola: " + documento.getNombre());
        
        // Inicia la impresión si no hay documentos imprimiéndose
        if (!imprimiendo) {
            iniciarProcesoImpresion();
        }
        actualizarVentanaCola();
    }

    // Inicia el proceso de impresión en un hilo separado
    private void iniciarProcesoImpresion() {
        if (hiloImpresion == null || !hiloImpresion.isAlive()) {
            imprimiendo = true;
            hiloImpresion = new Thread(() -> {
                while (!colaImpresion.isEmpty()) {
                    imprimirSiguiente();
                    actualizarVentanaCola();
                }
                imprimiendo = false;
                documentoActual = null;
                actualizarVentanaCola();
            });
            hiloImpresion.start();
        }
    }

    // Método para imprimir el siguiente documento en la cola
    private void imprimirSiguiente() {
        if (colaImpresion.isEmpty()) return;

        estado = "Ocupada";
        documentoActual = colaImpresion.peek();
        documentoActual.setEnImpresion(true);

        // Simula la impresión página por página
        for (int i = 1; i <= documentoActual.getNumPaginas(); i++) {
            documentoActual.setPaginasImpresas(i);
            actualizarVentanaCola();
            try {
                // Tiempo de espera según el tipo de documento
                switch (documentoActual.getTipo()) {
                    case "Texto": Thread.sleep(2000); break;
                    case "Imagen": Thread.sleep(4000); break;
                    case "PDF": Thread.sleep(3000); break;
                    case "Presentación": Thread.sleep(5000); break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // Finaliza la impresión del documento actual
        colaImpresion.poll();
        documentosImpresos++;
        estado = "Disponible";
    }

    // Muestra la ventana de cola de impresión
    public void mostrarCola() {
        ventanaCola.setVisible(true);
        actualizarVentanaCola();
    }

    // Actualiza la información mostrada en la ventana
    private void actualizarVentanaCola() {
        StringBuilder info = new StringBuilder();
        
        // Agrega información del estado de la impresora
        info.append("=== Estado de la Impresora ===\n");
        info.append("Estado: ").append(estado).append("\n");
        info.append("Documentos impresos: ").append(documentosImpresos).append("\n\n");

        // Muestra información del documento en impresión
        if (documentoActual != null) {
            info.append("=== Documento en Impresión ===\n");
            info.append("Nombre: ").append(documentoActual.getNombre()).append("\n");
            info.append("Progreso: ").append(documentoActual.getPaginasImpresas())
                .append("/").append(documentoActual.getNumPaginas()).append(" páginas\n\n");
        }

        // Muestra información de la cola de impresión
        info.append("=== Cola de Impresión ===\n");
        if (colaImpresion.isEmpty()) {
            info.append("No hay documentos en cola\n");
        } else {
            int posicion = 1;
            int tiempoEspera = 0;
            
            // Muestra información de cada documento en cola
            for (Documento doc : colaImpresion) {
                if (!doc.isEnImpresion()) {
                    info.append("\nPosición ").append(posicion).append(":\n");
                    info.append("Nombre: ").append(doc.getNombre()).append("\n");
                    info.append("Tipo: ").append(doc.getTipo()).append("\n");
                    info.append("Páginas: ").append(doc.getNumPaginas()).append("\n");
                    info.append("Origen: ").append(doc.getComputadoraOrigen()).append("\n");
                    info.append("Hora entrada: ").append(doc.getHoraEntrada().format(formatoHora)).append("\n");
                    info.append("Tiempo estimado: ").append(doc.getTiempoEstimado()).append(" segundos\n");
                    info.append("Tiempo de espera: ").append(tiempoEspera).append(" segundos\n");
                    
                    tiempoEspera += doc.getTiempoEstimado();
                    posicion++;
                }
            }
        }

        // Actualiza la ventana en el hilo de la interfaz gráfica
        SwingUtilities.invokeLater(() -> ventanaCola.actualizarCola(info.toString()));
    }
}

// Clase principal del sistema
 class SistemaImpresion {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ImpresoraRed impresora = new ImpresoraRed();
        boolean ejecutar = true;

        System.out.println("=== Sistema de Impresión en Red ===");
        
        // Bucle principal del programa
        while (ejecutar) {
            mostrarMenu();
            int opcion = leerOpcion(scanner);

            switch (opcion) {
                case 1:
                    agregarDocumento(scanner, impresora);
                    break;
                case 2:
                    impresora.mostrarCola();
                    break;
                case 3:
                    ejecutar = false;
                    System.out.println("\nSaliendo del sistema...");
                    break;
                default:
                    System.out.println("\nOpción no válida. Por favor, intente de nuevo.");
            }
        }
        scanner.close();
    }

    // Muestra el menú principal
    private static void mostrarMenu() {
        System.out.println("\n=== Menú Principal ===");
        System.out.println("1. Agregar documento a la cola");
        System.out.println("2. Ver estado de la impresora y cola");
        System.out.println("3. Salir");
        System.out.print("Seleccione una opción: ");
    }

    // Lee y valida la opción ingresada por el usuario
    private static int leerOpcion(Scanner scanner) {
        while (!scanner.hasNextInt()) {
            System.out.println("Por favor, ingrese un número válido.");
            scanner.next();
        }
        return scanner.nextInt();
    }

    // Método para agregar un nuevo documento
    private static void agregarDocumento(Scanner scanner, ImpresoraRed impresora) {
        scanner.nextLine(); // Limpiar el buffer

        System.out.println("\n=== Agregar Nuevo Documento ===");
        
        // Solicita el nombre del documento
        System.out.print("Ingrese el nombre del documento: ");
        String nombre = scanner.nextLine();

        // Muestra tipos de documento disponibles
        System.out.println("\nTipos de documento disponibles:");
        System.out.println("1. Texto");
        System.out.println("2. Imagen");
        System.out.println("3. PDF");
        System.out.println("4. Presentación");
        
        // Selección y validación del tipo de documento
        String tipo;
        do {
            System.out.print("Seleccione el tipo de documento (1-4): ");
            int tipoNum = leerOpcion(scanner);
            switch (tipoNum) {
                case 1: tipo = "Texto"; break;
                case 2: tipo = "Imagen"; break;
                case 3: tipo = "PDF"; break;
                case 4: tipo = "Presentación"; break;
                default: 
                    System.out.println("Opción no válida. Intente de nuevo.");
                    tipo = null;
            }
        } while (tipo == null);

        // Solicita número de páginas
        System.out.print("\nIngrese el número de páginas: ");
        int paginas = leerOpcion(scanner);

        // Muestra computadoras disponibles
        System.out.println("\nComputadoras disponibles:");
        System.out.println("1. PC1");
        System.out.println("2. PC2");
        System.out.println("3. PC3");
        System.out.println("4. PC4");
        
        // Selección y validación de la computadora
        String computadora;
        do {
            System.out.print("Seleccione la computadora de origen (1-4): ");
            int pcNum = leerOpcion(scanner);
            switch (pcNum) {
                case 1: computadora = "PC1"; break;
                case 2: computadora = "PC2"; break;
                case 3: computadora = "PC3"; break;
                case 4: computadora = "PC4"; break;
                default:
                    System.out.println("Opción no válida. Intente de nuevo.");
                    computadora = null;
            }
        } while (computadora == null);

        // Crea y agrega el nuevo documento a la cola
        Documento doc = new Documento(nombre, tipo, paginas, computadora);
        impresora.agregarDocumento(doc);
    }
}