planeacion.py

import tkinter as tk
from tkinter import ttk
from funciones.Planeacion_db import dbPlaneacion

class Ventana_Planeacion:
    def __init__(self, tab, id_usuario):
        self.tab = tab
        self.id_usuario = id_usuario  # Se pasa el id_usuario
        self.db = dbPlaneacion()  
        self.grupos = self.db.comparar_usuario_grupo(self.id_usuario)  # Obtener los grupos del usuario

        if self.grupos:
            print(f"ID de usuario {self.id_usuario} encontrado con {len(self.grupos)} grupos.")
        else:
            print(f"ID de usuario {self.id_usuario} no tiene grupos asociados.")

        self.columna_dias = {
            1: "Lunes",      # Columna 1: Lunes
            2: "Martes",     # Columna 2: Martes
            3: "Miércoles",  # Columna 3: Miércoles
            4: "Jueves",     # Columna 4: Jueves
            5: "Viernes"     # Columna 5: Viernes
        }

        self.fila_horas = {
            1: "7-9",
            2: "9-11",
            3: "11-13",
            4: "13-15",
            5: "15-17",
            6: "17-19",
            7: "19-21",
        }

        self.crear_widgets()

    def convertir_dias(self, dias):
        # Diccionario que mapea los días de la semana a sus números correspondientes
        dias_mapping = {
            "lunes": 1,
            "martes": 2,
            "miercoles": 3,
            "jueves": 4,
            "viernes": 5
        }

        # Separar la cadena de días por guión y convertirlos en números
        dias_lista = dias.lower().split(" - ")
        dias_numeros = [dias_mapping[dia.strip()] for dia in dias_lista if dia.strip() in dias_mapping]
        return dias_numeros

    def obtener_fila_hora(self, entrada, salida):
        # Mapeo de las horas a las filas correspondientes
        horario_mapping = {
            "07:00": 1,  # 07:00 - 09:00 en la fila 1
            "09:00": 2,  # 09:00 - 11:00 en la fila 2
            "11:00": 3,  # 11:00 - 13:00 en la fila 3
            "13:00": 4,  # 13:00 - 15:00 en la fila 4
            "15:00": 5,  # 15:00 - 17:00 en la fila 5
            "17:00": 6,  # 17:00 - 19:00 en la fila 6
            "19:00": 7,  # 19:00 - 21:00 en la fila 7
        }
        
        # Verificar si la entrada tiene una hora válida en el diccionario
        if entrada in horario_mapping:
            return horario_mapping[entrada]
        else:
            print(f"Hora no válida: {entrada}")
            return None


    def convertir_horario(self, id_horario):
        # Llamar a la función obtener_nombre_horario del código 1 usando el id_horario
        nombre_horario = self.db.obtener_nombre_horario(id_horario)
        print(f"Nombre de horario recibido: {nombre_horario}")
        # Mapeo de los horarios a horas de entrada y salida (ajustado a tu formato)
        horario_mapping = {
            "07:00 - 09:00": ("07:00", "09:00"),
            "09:00 - 11:00": ("09:00", "11:00"),
            "11:00 - 13:00": ("11:00", "13:00"),
            "13:00 - 15:00": ("13:00", "15:00"),
            "15:00 - 17:00": ("15:00", "17:00"),
            "17:00 - 19:00": ("17:00", "19:00"),
            "19:00 - 21:00": ("19:00", "21:00"),
        }

        # Verificar si el horario es válido y retornar la hora de entrada y salida
        if nombre_horario in horario_mapping:
            print(f"Horario reconocido: {nombre_horario}")
            return horario_mapping[nombre_horario]
        else:
            print("Horario no reconocido")
            return None


    def crear_widgets(self):
        for i in range(8):  
            self.tab.rowconfigure(i, weight=1)
        for j in range(6): 
            self.tab.columnconfigure(j, weight=1)

        # Encabezados de días de la semana
        for columna, dia in self.columna_dias.items():
            etiqueta = tk.Label(self.tab, text=dia, width=12, height=4, relief="solid", anchor="center", bg="#4682B4", fg="white", font=("Arial", 12, "bold"))
            etiqueta.grid(row=0, column=columna, sticky="nsew", padx=5, pady=5)

        # Encabezados de horas
        for fila, hora in self.fila_horas.items():
            etiqueta = tk.Label(self.tab, text=hora, width=12, height=2, relief="solid", anchor="center", bg="#4682B4", fg="white", font=("Arial", 12, "bold"))
            etiqueta.grid(row=fila, column=0, sticky="nsew", padx=5, pady=5)

        # Crear la cuadrícula de etiquetas para los grupos
        for fila in range(1, 8): 
            for columna in range(1, 6):  
                etiqueta = tk.Label(self.tab, text="", width=10, height=5, relief="raised", anchor="center", bg="#D3D3D3", font=("Arial", 10))

                # Vincula el evento de clic para mostrar el día y hora
                etiqueta.bind("<Button-1>", lambda event, col=columna, row=fila: self.mostrar_dia_hora(event, col, row))

                # Verificar si hay un grupo para asignar al cuadro
                for grupo_info in self.grupos:
                    # Convertir los días del grupo de "Lunes-Miercoles" a una lista de números
                    dias_grupo = self.convertir_dias(grupo_info[7])  # Esto devuelve una lista de números como [1, 3]
                    print(f"Grupo: {grupo_info[1]} - Días asignados: {dias_grupo}")  # Imprimir para verificar los días

                    # Verificar si el grupo debe ir en este día
                    if columna in dias_grupo:
                        # Obtener el horario del grupo
                        id_horario = grupo_info[8]  # Acceder al 'id_horario' en el índice 8
                        horas = self.convertir_horario(id_horario)
                        
                        if horas:
                            entrada, salida = horas
                            # Verificar si la hora del grupo corresponde a la fila actual (hora)
                            if fila == self.obtener_fila_hora(entrada, salida):  # Aquí se verifica si la fila corresponde a la hora
                                etiqueta.config(text=f"Grupo: {grupo_info[1]}\n{entrada} - {salida}")  # Mostrar horario también

                                # Vincular el id_grupo al evento de clic para abrir la ventana
                                etiqueta.bind("<Button-1>", lambda event, col=columna, row=fila, id_grupo=grupo_info[0]: self.abrir_ventana(id_grupo))

                etiqueta.grid(row=fila, column=columna, sticky="nsew", padx=5, pady=5)

    def mostrar_dia_hora(self, event, columna, fila):
        dia = self.columna_dias.get(columna, "Desconocido")
        hora = self.fila_horas.get(fila, "Desconocida")
        print(f"Celda seleccionada - Día: {dia}, Hora: {hora}")

    def abrir_ventana(self, id_grupo):
        try:
            # Obtener la información del grupo
            grupo_info = self.db.obtener_informacion_grupo(id_grupo)

            if grupo_info:
                # Desestructurar el diccionario
                Seccion = grupo_info['seccion']
                Fecha = grupo_info['fecha']
                Id_Carrera = grupo_info['id_carrera']
                Id_Materia = grupo_info['id_materia']
                Id_Maestro = grupo_info['id_maestro']
                Id_Salon = grupo_info['id_salon']
                Dias = grupo_info['dias']
                Id_Horario = grupo_info['id_horario']
                Ciclo = grupo_info['ciclo']
                Max_num_Alumno = grupo_info['max_num_alumno']

                # Obtener los nombres relacionados
                nombre_carrera = self.db.obtener_nombre_carrera(Id_Carrera)
                nombre_asignatura = self.db.obtener_nombre_materia(Id_Materia)
                nombre_maestro = self.db.obtener_nombre_maestro(Id_Maestro)
                nombre_salon = self.db.obtener_nombre_salon(Id_Salon)
                nombre_horario = self.db.obtener_nombre_horario(Id_Horario)

                # Crear una nueva ventana
                nueva_ventana = tk.Toplevel(self.tab)
                nueva_ventana.geometry("500x400")
                nueva_ventana.title("Información del Grupo")
                nueva_ventana.config(bg="#F7F7F7")

                # Encabezado de la ventana
                encabezado = tk.Label(
                    nueva_ventana, 
                    text="Detalles del Grupo", 
                    font=("Arial", 14, "bold"), 
                    bg="#4682B4", 
                    fg="white", 
                    padx=10, 
                    pady=10
                )
                encabezado.pack(fill="x")

                # Marco para el contenido
                frame_contenido = tk.Frame(nueva_ventana, bg="#F7F7F7", padx=20, pady=10)
                frame_contenido.pack(fill="both", expand=True)

                # Información del grupo
                datos = [
                    f"Sección: {Seccion}",
                    f"Carrera: {nombre_carrera}",
                    f"Materia: {nombre_asignatura}",
                    f"Maestro: {nombre_maestro}",
                    f"Salón: {nombre_salon}",
                    f"Días: {Dias}",
                    f"Horario: {nombre_horario}",
                    f"Máx. Alumnos: {Max_num_Alumno}",
                    f"Ciclo: {Ciclo}",
                    f"Fecha: {Fecha}"
                ]

                # Mostrar cada dato como una etiqueta
                for dato in datos:
                    tk.Label(
                        frame_contenido, 
                        text=dato, 
                        font=("Arial", 11), 
                        bg="#F7F7F7", 
                        anchor="w"
                    ).pack(fill="x", pady=2)

                # Botón para cerrar la ventana
                boton_cerrar = tk.Button(
                    nueva_ventana, 
                    text="Cerrar", 
                    font=("Arial", 11), 
                    bg="#E57373", 
                    fg="white", 
                    command=nueva_ventana.destroy
                )
                boton_cerrar.pack(pady=10, ipadx=10, ipady=5)

        except Exception as e:
            print(f"Error al abrir la ventana de información: {e}")