main.py

# main.py

import customtkinter as ctk
import tkinter as tk
from tkinter import messagebox
from database import *
from typing import Optional


try:
    from CTkMessagebox import CTkMessagebox
except ImportError:
    
    CTkMessagebox = messagebox

ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")

class App(ctk.CTk):
    def __init__(self):
        super().__init__()

        self.title("📚 Sistema Bibliotecário")
        self.geometry("1080x640")
        self.eval('tk::PlaceWindow . center')
        
        # Variáveis de estado do usuário
        self.user_type: Optional[str] = None # 'cliente' ou 'admin'
        self.username: Optional[str] = None
        self.emprestimos_atuais: int = 0 
        self.cadastro_callback = self.tela_login # Define o login como o padrão

        # Mostra a tela de login primeiro
        self.tela_login()

    # --- Funções de Navegação e Auxiliares ---

    def limpar_tela(self):
        """Remove todos os widgets da tela."""
        for widget in self.winfo_children():
            widget.destroy()

    def exibir_mensagem(self, titulo: str, mensagem: str, tipo: str = "info"):
        """Exibe uma mensagem na tela usando CTkMessagebox ou tkinter.messagebox."""
        if CTkMessagebox.__module__ == 'CTkMessagebox':
             
            if tipo == "erro":
                CTkMessagebox(title=titulo, message=mensagem, icon="cancel")
            elif tipo == "sucesso":
                 CTkMessagebox(title=titulo, message=mensagem, icon="check", option_1="OK")
            else: 
                CTkMessagebox(title=titulo, message=mensagem, icon="info")
        else:
            
            if tipo == "erro":
                messagebox.showerror(titulo, mensagem)
            elif tipo == "sucesso":
                messagebox.showinfo(titulo, mensagem)
            else: 
                messagebox.showinfo(titulo, mensagem)


    # --- Telas de Autenticação ---

    def tela_login(self):
        self.limpar_tela()

        frame = ctk.CTkFrame(self, width=450, height=450, corner_radius=15)
        frame.place(relx=0.5, rely=0.5, anchor="center")

        titulo = ctk.CTkLabel(frame, text="🔑 Login", font=("Arial", 24, "bold"))
        titulo.pack(pady=20)

        ctk.CTkLabel(frame, text="Usuário:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_usuario = ctk.CTkEntry(frame, placeholder_text="Digite seu usuário", width=250)
        self.entry_usuario.pack(pady=10)

        ctk.CTkLabel(frame, text="Senha:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_senha = ctk.CTkEntry(frame, placeholder_text="Digite sua senha", show="*", width=250)
        self.entry_senha.pack(pady=10)

        ctk.CTkButton(frame, text="Entrar", width=150, command=self.validar_login).pack(pady=15)

        ctk.CTkLabel(frame, text="Não tem uma conta?").pack(pady=(20, 0))
        ctk.CTkButton(frame, text="Cadastrar-se", width=150, fg_color="green", command=self.navegar_para_cadastro_cliente).pack(pady=5)

    def tela_cadastro(self):
        self.limpar_tela()

        frame = ctk.CTkFrame(self, width=400, height=550, corner_radius=15)
        frame.place(relx=0.5, rely=0.5, anchor="center")

        titulo = ctk.CTkLabel(frame, text="📝 Cadastro de Cliente", font=("Arial", 24, "bold"))
        titulo.pack(pady=20)

        ctk.CTkLabel(frame, text="Nome completo:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_nome_cadastro= ctk.CTkEntry(frame, placeholder_text="Digite seu nome completo", width=250)
        self.entry_nome_cadastro.pack(pady=10)
        
        ctk.CTkLabel(frame, text="Nome de usuário:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_user_name_cadastro = ctk.CTkEntry(frame, placeholder_text="Digite um nome de usuário", width=250)
        self.entry_user_name_cadastro.pack(pady=10)

        ctk.CTkLabel(frame, text="Email:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_email_cadastro = ctk.CTkEntry(frame, placeholder_text="Digite seu email", width=250)
        self.entry_email_cadastro.pack(pady=10)

        ctk.CTkLabel(frame, text="Senha:", font = ("Arial", 16, "bold")).pack(pady=(10, 0))
        self.entry_senha_cadastro = ctk.CTkEntry(frame, placeholder_text="Digite sua senha", show="*", width=250)
        self.entry_senha_cadastro.pack(pady=10)

        ctk.CTkButton(frame, text="Cadastrar", width=150, fg_color="green", command=self.cadastrar_usuario).pack(pady=15)
        ctk.CTkButton(frame, text="Voltar", width=150, fg_color="gray30", command=self.cadastro_callback).pack(pady=10)

    # Em main.py

    def navegar_para_cadastro_cliente(self):
        """Define o callback para voltar ao LOGIN."""
        self.cadastro_callback = self.tela_login
        self.tela_cadastro()

    def navegar_para_cadastro_admin(self):
        """Define o callback para voltar à GESTÃO DE CLIENTES."""
        self.cadastro_callback = self.tela_admin
        self.tela_cadastro()

    # --- Lógica de Autenticação ---

    def validar_login(self):
        user_name = self.entry_usuario.get()
        senha_digitada = self.entry_senha.get()
        
        # 1. Login Fixo de Admin (Hardcoded)
        if user_name == "admin" and senha_digitada == "123":
            self.user_type = "admin"
            self.username = "admin"
            self.exibir_mensagem("Sucesso", "Bem-vindo(a), Admin!", "sucesso")
            self.tela_admin()
            return
        
        # 2. Tenta login como Cliente (Verifica no Banco de Dados)
        try:
            # Chama a função do banco para buscar a senha do cliente
            resultado = get_senha_user(user_name) 
            
            if resultado:
                senha_cliente_bd, type_user_bd = resultado
                
                
                if senha_cliente_bd and senha_cliente_bd == senha_digitada: 
                    self.user_type = type_user_bd
                    self.username = user_name
                    
                    if type_user_bd == 'cliente':
                        
                        try:
                            id_cli = get_id_cliente(self.username)
                            # (Esta função precisa ser criada no SQL e no database.py)
                            self.emprestimos_atuais = contar_emprestimos_ativos_cliente(id_cli) 
                        except Exception as e:
                            self.exibir_mensagem("Erro", f"Falha ao carregar limite de empréstimos: {e}", "erro")
                            self.emprestimos_atuais = 99 # Bloqueia empréstimos por segurança
                        
                        self.exibir_mensagem("Sucesso", f"Bem-vindo(a), Cliente {user_name}!", "sucesso")
                        self.tela_cliente()
                    
                    elif type_user_bd == 'admin':
                        self.exibir_mensagem("Sucesso", f"Bem-vindo(a), Admin {user_name}!", "sucesso")
                        self.tela_admin()
                    return
        except Exception as e:
            print(f"Erro ao tentar login cliente: {e}") 
            # Continua para a falha de login abaixo

        # 3. Falha no Login
        self.exibir_mensagem("Erro de Login", "Nome de usuário ou senha incorretos.", "erro")

    def cadastrar_usuario(self):       
        nome = self.entry_nome_cadastro.get()
        user_name = self.entry_user_name_cadastro.get()
        email = self.entry_email_cadastro.get()
        senha = self.entry_senha_cadastro.get()
        
        if not nome or not user_name or not email or not senha:
            self.exibir_mensagem("Erro de Cadastro", "Preencha todos os campos.", "erro")
            return

        try:
            inserir_cliente(nome, user_name, email, senha)
            self.exibir_mensagem("Sucesso", "Cadastro realizado com sucesso!", "sucesso")
            self.cadastro_callback() # <-- Chama a função que foi guardada
        except Exception as e:
            self.exibir_mensagem("Erro de Banco de Dados", str(e).split('\n')[0], "erro")


    # --- Telas Principais ---

    def tela_gerenciar_emprestimos(self):
        """Tela do Admin para ver livros emprestados e registrar devoluções."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(main_frame, text="🔄 Empréstimos Ativos (Devolução)", 
                     font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w", pady=(0, 10))
        
        self.scroll_frame_ativos = ctk.CTkScrollableFrame(main_frame, label_text="Livros Atualmente Emprestados")
        self.scroll_frame_ativos.grid(row=1, column=0, sticky="nsew", pady=(10, 20))
        self.scroll_frame_ativos.grid_columnconfigure(0, weight=1)

        self.carregar_emprestimos_ativos()

    def carregar_emprestimos_ativos(self):
        """Busca e exibe os empréstimos ativos, incluindo o botão de devolução."""
        
        for widget in self.scroll_frame_ativos.winfo_children():
            widget.destroy()

        try:
            ativos = func_relatorio_emprestimos_ativos()
            
            if not ativos:
                ctk.CTkLabel(self.scroll_frame_ativos, text="🎉 Nenhum livro atualmente emprestado.").grid(row=0, column=0, padx=20, pady=20)
                return

            # --- Cabeçalho ---
            header_frame = ctk.CTkFrame(self.scroll_frame_ativos, fg_color="gray25")
            header_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=(5, 0))
            header_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)
            
            ctk.CTkLabel(header_frame, text="Empréstimo ID", font=("Arial", 14, "bold")).grid(row=0, column=0, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Livro", font=("Arial", 14, "bold")).grid(row=0, column=1, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Cliente", font=("Arial", 14, "bold")).grid(row=0, column=2, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Data Empr.", font=("Arial", 14, "bold")).grid(row=0, column=3, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Ação", font=("Arial", 14, "bold")).grid(row=0, column=4, padx=5, pady=5)

            # --- Linhas de Dados ---
            for i, item in enumerate(ativos):
                id_empr, titulo, cliente, data_init, _ = item
                
                linha_frame = ctk.CTkFrame(self.scroll_frame_ativos, fg_color=("gray85", "gray17"))
                linha_frame.grid(row=i + 1, column=0, sticky="ew", padx=5, pady=2)
                linha_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)

                ctk.CTkLabel(linha_frame, text=id_empr).grid(row=0, column=0, padx=5, pady=5)
                ctk.CTkLabel(linha_frame, text=titulo, anchor="w").grid(row=0, column=1, padx=5, pady=5, sticky="w")
                ctk.CTkLabel(linha_frame, text=cliente, anchor="w").grid(row=0, column=2, padx=5, pady=5, sticky="w")
                ctk.CTkLabel(linha_frame, text=str(data_init)).grid(row=0, column=3, padx=5, pady=5)
                
                ctk.CTkButton(linha_frame, text="Devolver", width=80, fg_color="red", 
                              command=lambda lid=id_empr, ltit=titulo, lcli=cliente: self.devolver_livro_admin(lid, ltit, lcli)).grid(row=0, column=4, padx=5, pady=5)
                
        except Exception as e:
            self.exibir_mensagem("Erro", f"Ocorreu um erro ao carregar empréstimos ativos: {e}", "erro")

    def devolver_livro_admin(self, id_emprestimo: int, titulo: str, cliente: str):
        """Lógica para registrar a devolução no DB."""
        
        try:
            # Busca o ID do admin logado (self.username)
            id_admin_sistema = get_id_admin(self.username)
            if id_admin_sistema is None:
                raise Exception(f"Não foi possível encontrar o ID do admin '{self.username}'")

            msg = CTkMessagebox(title="Confirmação de Devolução", 
                                message=f"Confirmar devolução do livro:\n'{titulo}'\npor {cliente}?",
                                icon="question", 
                                option_1="Cancelar", 
                                option_2="Confirmar",
                                master=self)
            
            resposta = msg.get()

            if resposta == "Confirmar":
                registrar_devolucao(id_emprestimo, id_admin_sistema)
                self.exibir_mensagem("Sucesso", f"Devolução registrada para o livro '{titulo}'!", "sucesso")
                self.carregar_emprestimos_ativos()
                
        except Exception as e:
            self.exibir_mensagem("Erro de Devolução", f"Falha ao registrar devolução:\n{e}", "erro")

    def tela_meus_emprestimos(self):
        """Tela do cliente para visualizar o histórico e empréstimos ativos."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(main_frame, text=f"🧾 Meus Empréstimos ({self.username})", 
                     font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w", pady=(0, 10))
        
        self.scroll_frame_historico = ctk.CTkScrollableFrame(main_frame, label_text="Histórico de Empréstimos")
        self.scroll_frame_historico.grid(row=1, column=0, sticky="nsew", pady=(10, 20))
        self.scroll_frame_historico.grid_columnconfigure(0, weight=1)

        self.carregar_historico_cliente()

    def carregar_historico_cliente(self):
        """Busca e exibe o histórico de empréstimos do cliente."""
        
        for widget in self.scroll_frame_historico.winfo_children():
            widget.destroy()

        try:
            historico = func_historico_emprestimos_usuario(self.username)
            
            if not historico:
                ctk.CTkLabel(self.scroll_frame_historico, text="Você não possui histórico de empréstimos.").grid(row=0, column=0, padx=20, pady=20)
                return

            # --- Cabeçalho ---
            header_frame = ctk.CTkFrame(self.scroll_frame_historico, fg_color="gray25")
            header_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=(5, 0))
            header_frame.grid_columnconfigure((0, 1, 2, 3), weight=1)
            
            ctk.CTkLabel(header_frame, text="Empréstimo ID", font=("Arial", 14, "bold")).grid(row=0, column=0, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Livros", font=("Arial", 14, "bold")).grid(row=0, column=1, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Data Empr.", font=("Arial", 14, "bold")).grid(row=0, column=2, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Status/Devolução", font=("Arial", 14, "bold")).grid(row=0, column=3, padx=5, pady=5)

            # --- Linhas de Dados ---
            for i, item in enumerate(historico):
                # CORREÇÃO: Desempacota 5 colunas
                id_empr, data_init, data_devol, livros, status = item
                
                linha_frame = ctk.CTkFrame(self.scroll_frame_historico, fg_color=("gray85", "gray17"))
                linha_frame.grid(row=i + 1, column=0, sticky="ew", padx=5, pady=2)
                linha_frame.grid_columnconfigure((0, 1, 2, 3), weight=1)

                # CORREÇÃO: Usa o status vindo do DB
                data_devol_str = str(data_devol) if data_devol else "---"
                cor_status = "green" if status == 'ATIVO' else "gray"
                
                texto_status = status
                if status == 'DEVOLVIDO':
                    texto_status = f"Devolvido em {data_devol_str}"

                ctk.CTkLabel(linha_frame, text=id_empr).grid(row=0, column=0, padx=5, pady=5)
                ctk.CTkLabel(linha_frame, text=livros, anchor="w").grid(row=0, column=1, padx=5, pady=5, sticky="w")
                ctk.CTkLabel(linha_frame, text=str(data_init)).grid(row=0, column=2, padx=5, pady=5)
                ctk.CTkLabel(linha_frame, text=texto_status, 
                             text_color=cor_status).grid(row=0, column=3, padx=5, pady=5)
                
        except Exception as e:
            self.exibir_mensagem("Erro", f"Ocorreu um erro ao carregar seus empréstimos: {e}", "erro")

    def tela_emprestimo_livros(self):
        """Tela para o ADMIN registrar um empréstimo para um cliente."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(3, weight=1) # CORREÇÃO: Linha do scroll_frame

        ctk.CTkLabel(main_frame, text="🛒 Registrar Empréstimo (Admin)", 
                     font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w", pady=(0, 10))
        
        # --- CAMPO DE CLIENTE ---
        cliente_frame = ctk.CTkFrame(main_frame)
        cliente_frame.grid(row=1, column=0, sticky="ew", pady=(10, 0))
        cliente_frame.grid_columnconfigure(1, weight=1)
        
        ctk.CTkLabel(cliente_frame, text="Usuário do Cliente:", 
                     font=ctk.CTkFont(weight="bold")).grid(row=0, column=0, padx=10, pady=10)
        self.entry_cliente_emprestimo = ctk.CTkEntry(cliente_frame, placeholder_text="Digite o user_name do cliente")
        self.entry_cliente_emprestimo.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        
        # --- CORREÇÃO: Widgets de Pesquisa de Livro Faltando ---
        search_frame = ctk.CTkFrame(main_frame)
        search_frame.grid(row=2, column=0, sticky="ew", pady=(10, 10))
        search_frame.grid_columnconfigure(1, weight=1)
        
        ctk.CTkLabel(search_frame, text="Buscar Livro:").grid(row=0, column=0, padx=10, pady=10)
        self.entry_busca_emprestimo = ctk.CTkEntry(search_frame, placeholder_text="Buscar por Título, Autor, Categoria...")
        self.entry_busca_emprestimo.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        ctk.CTkButton(search_frame, text="Buscar 🔍", 
                      command=self.executar_busca_emprestimo).grid(row=0, column=2, padx=10, pady=10)

        # --- CORREÇÃO: ScrollFrame Faltando ---
        self.scroll_frame_emprestimo = ctk.CTkScrollableFrame(main_frame, label_text="Livros Disponíveis para Empréstimo")
        self.scroll_frame_emprestimo.grid(row=3, column=0, sticky="nsew", pady=(0, 20))
        self.scroll_frame_emprestimo.grid_columnconfigure(0, weight=1)
        
        # Carrega a lista de livros
        self.executar_busca_emprestimo(termo="")


    def executar_busca_emprestimo(self, termo: Optional[str] = None):
        """Busca livros e atualiza a exibição com um botão de Empréstimo."""
        
        if termo is None:
            termo = self.entry_busca_emprestimo.get()

        for widget in self.scroll_frame_emprestimo.winfo_children():
            widget.destroy()

        try:
            resultados = buscar_livros(termo)
            
            header_frame = ctk.CTkFrame(self.scroll_frame_emprestimo, fg_color="gray25")
            header_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=(5, 0))
            header_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)
            
            ctk.CTkLabel(header_frame, text="ID", font=("Arial", 14, "bold"), width=30).grid(row=0, column=0, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Título", font=("Arial", 14, "bold"), width=250).grid(row=0, column=1, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Autor", font=("Arial", 14, "bold"), width=150).grid(row=0, column=2, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Disponíveis", font=("Arial", 14, "bold"), width=80).grid(row=0, column=3, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Ação", font=("Arial", 14, "bold"), width=100).grid(row=0, column=4, padx=5, pady=5) # Novo
            
            if not resultados:
                ctk.CTkLabel(self.scroll_frame_emprestimo, text="Nenhum livro disponível encontrado.").grid(row=1, column=0, padx=20, pady=20)
                return

            for i, livro in enumerate(resultados):
                
                # CORREÇÃO (Bug de Desempacotamento): Espera 6 colunas
                # (id_livro, isbn, titulo, autor, num_copias, copias_disponiveis)
                id_livro, _, titulo, autor, _, copias_disponiveis = livro 
                
                if(copias_disponiveis <= 0): # Não mostra livros esgotados
                    continue 

                livro_frame = ctk.CTkFrame(self.scroll_frame_emprestimo, fg_color=("gray85", "gray17"))
                livro_frame.grid(row=i + 1, column=0, sticky="ew", padx=5, pady=2)
                livro_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)
                
                ctk.CTkLabel(livro_frame, text=id_livro, width=30).grid(row=0, column=0, padx=5, pady=5)
                ctk.CTkLabel(livro_frame, text=titulo, width=250, anchor="w").grid(row=0, column=1, padx=5, pady=5, sticky="w")
                ctk.CTkLabel(livro_frame, text=autor, width=150, anchor="w").grid(row=0, column=2, padx=5, pady=5, sticky="w")
                
                cor_copias = "red" if copias_disponiveis <= 0 else "green"
                ctk.CTkLabel(livro_frame, text=copias_disponiveis, text_color=cor_copias, width=80).grid(row=0, column=3, padx=5, pady=5)
                
                # Botão de Empréstimo (Ação)
                btn_emprestar = ctk.CTkButton(livro_frame, text="Emprestar", width=80, 
                                                command=lambda lid=id_livro, ltit=titulo: self.emprestar_livro(lid, ltit))
                btn_emprestar.grid(row=0, column=4, padx=5, pady=5)
                
        except Exception as e:
            self.exibir_mensagem("Erro de Busca", f"Ocorreu um erro ao buscar livros: {e}", "erro")


    def tela_cliente(self):
        """Tela principal para Clientes: Visualização e Pesquisa de Livros."""
        self.limpar_tela()
        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(1, weight=1)

        # 1. Sidebar
        sidebar_frame = ctk.CTkFrame(self, width=140, corner_radius=0)
        sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew")
        sidebar_frame.grid_rowconfigure(4, weight=1)

        ctk.CTkLabel(sidebar_frame, text="📚 Cliente", font=ctk.CTkFont(size=20, weight="bold")).grid(row=0, column=0, padx=20, pady=(20, 10))
        ctk.CTkLabel(sidebar_frame, text=f"Usuário: {self.username}", wraplength=100).grid(row=1, column=0, padx=20, pady=(0, 10))
        
        ctk.CTkButton(sidebar_frame, text="Início/Livros", command=self.tela_cliente).grid(row=2, column=0, padx=20, pady=10)
        ctk.CTkButton(sidebar_frame, text="Meus Empréstimos", command = self.tela_meus_emprestimos).grid(row=3, column=0, padx=20, pady=10)
        ctk.CTkButton(sidebar_frame, text="Configuraçoes", command = self.tela_configuracao_usuario).grid(row=4, column=0, padx=20, pady=10)

        ctk.CTkButton(sidebar_frame, text="Sair", fg_color="red", command=self.logout).grid(row=5, column=0, padx=20, pady=(10, 20))


        # 2. Área de Conteúdo (Livros)
        search_frame = ctk.CTkFrame(self)
        search_frame.grid(row=0, column=1, padx=20, pady=(20, 10), sticky="ew")
        search_frame.grid_columnconfigure(1, weight=1)

        ctk.CTkLabel(search_frame, text="Pesquisar Livros (Título, Autor, ISBN ou Categoria):").grid(row=0, column=0, padx=10, pady=10)
        self.entry_busca_cliente = ctk.CTkEntry(search_frame, placeholder_text="Termo de Busca")
        self.entry_busca_cliente.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        ctk.CTkButton(search_frame, text="Buscar 🔍", command=self.executar_busca_livros).grid(row=0, column=2, padx=10, pady=10)
        
        self.scroll_frame_livros = ctk.CTkScrollableFrame(self, label_text="Catálogo de Livros")
        self.scroll_frame_livros.grid(row=1, column=1, padx=20, pady=(0, 20), sticky="nsew", rowspan=3)
        self.scroll_frame_livros.grid_columnconfigure(0, weight=1)

        self.executar_busca_livros(termo="")

    
    def atualizar_senha(self):
        """Lógica para o botão Atualizar Senha."""
        nova_senha = self.entry_nova_senha.get()
        confirmar_senha = self.entry_confirmar_senha.get()
        
        if not nova_senha or nova_senha != confirmar_senha:
            self.exibir_mensagem("Erro de Senha", "Senhas não coincidem ou campo vazio.", "erro")
            return

        try:
            # Chama a função DB (CORREÇÃO: Removido 'self.')
            atualizar_perfil_cliente(
                curr_user_name=self.username,
                p_nome=None,
                p_user_name=None,
                p_email=None,
                p_senha=nova_senha # Este é o único campo a ser alterado
            ) 
            self.exibir_mensagem("Sucesso", "Senha atualizada! Faça login novamente.", "sucesso")
            self.logout()
        except Exception as e:
            self.exibir_mensagem("Erro de DB", f"Falha ao atualizar a senha: {str(e).split('\n')[0]}", "erro")
    

    def tela_configuracao_usuario(self):
        """
        Exibe a tela de configuração de perfil, permitindo a edição de campos 
        individuais (Nome, Username, Email) via botões com ícones.
        """
        # 1. Limpeza da área principal
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(2, weight=1)

        ctk.CTkLabel(main_frame, text="⚙️ Configurações do Perfil",
                    font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w", pady=(0, 20))

        try:
            # Busca os dados do usuário logado no banco de dados
            # (id, nome, user_name, email, type_user)
            dados_usuario = get_dados_usuario(self.username)
            if not dados_usuario:
                raise Exception("Usuário não encontrado no banco de dados.")

            _, nome, username,_, email = dados_usuario 
            
        except Exception as e:
            self.exibir_mensagem("Erro de Dados", f"Falha ao carregar dados do usuário: {e}", "erro")
            ctk.CTkLabel(main_frame, text="Não foi possível carregar os dados. Tente novamente.", text_color="red").grid(row=1, column=0, padx=20, pady=20)
            return

        # 2. Frame de Exibição de Dados (Com Botões de Edição)
        dados_frame = ctk.CTkFrame(main_frame, fg_color="gray25")
        dados_frame.grid(row=1, column=0, sticky="ew", pady=(0, 20), padx=20)
        dados_frame.grid_columnconfigure(1, weight=1)
        
        ctk.CTkLabel(dados_frame, text="Seus Dados Atuais", font=("Arial", 18, "bold")).grid(row=0, column=0, columnspan=3, pady=(15, 10), sticky="w", padx=20)

        # Campos que podem ser editados
        self.exibir_campo_editavel(dados_frame, "Nome Completo:", nome, 1, 'nome', 'Nome Completo')
        self.exibir_campo_editavel(dados_frame, "Nome de Usuário:", username, 2, 'user_name', 'Nome de Usuário')
        self.exibir_campo_editavel(dados_frame, "Email:", email, 3, 'email', 'Email')

        # Campo somente leitura (Tipo de Conta)
        


        # 3. Frame de Alteração de Senha (Mantido no local para facilidade)
        senha_frame = ctk.CTkFrame(main_frame)
        senha_frame.grid(row=2, column=0, sticky="ew", pady=(10, 20), padx=20)
        senha_frame.grid_columnconfigure(0, weight=1)

        ctk.CTkLabel(senha_frame, text="Mudar Senha 🔑", font=("Arial", 18, "bold")).pack(pady=(15, 10))

        ctk.CTkLabel(senha_frame, text="Nova Senha:").pack(pady=(5, 0))
        self.entry_nova_senha = ctk.CTkEntry(senha_frame, placeholder_text="Digite sua nova senha", show="*", width=300)
        self.entry_nova_senha.pack(pady=5)

        ctk.CTkLabel(senha_frame, text="Confirmar Nova Senha:").pack(pady=(5, 0))
        self.entry_confirmar_senha = ctk.CTkEntry(senha_frame, placeholder_text="Confirme sua nova senha", show="*", width=300)
        self.entry_confirmar_senha.pack(pady=5)

        ctk.CTkButton(senha_frame, text="Atualizar Senha 💾", 
                    fg_color="orange", hover_color="darkorange",
                    command=self.atualizar_senha).pack(pady=(15, 20))


    def exibir_campo_somente_leitura(self, master, label_text, value, row):
        """Cria um Label/Entry somente leitura."""
        ctk.CTkLabel(master, text=label_text, font=("Arial", 14, "bold"), anchor="w", width=150).grid(row=row, column=0, padx=(20, 10), pady=5, sticky="w")
        
        entry = ctk.CTkEntry(master, width=280)
        entry.insert(0, str(value))
        entry.configure(state="readonly") 
        entry.grid(row=row, column=1, padx=(0, 10), pady=5, sticky="ew")
        ctk.CTkLabel(master, text="🔒", width=20).grid(row=row, column=2, padx=(0, 20), pady=5, sticky="e")

    def exibir_campo_editavel(self, master, label_text, value, row, campo_db, titulo_edicao):
        """Cria um Label/Entry somente leitura com um botão de edição (canetinha)."""
        ctk.CTkLabel(master, text=label_text, font=("Arial", 14, "bold"), anchor="w", width=150).grid(row=row, column=0, padx=(20, 10), pady=5, sticky="w")
        
        entry = ctk.CTkEntry(master, width=280)
        entry.insert(0, str(value))
        entry.configure(state="readonly") 
        entry.grid(row=row, column=1, padx=(0, 10), pady=5, sticky="ew")
        
        # Botão de Canetinha
        ctk.CTkButton(master, text="✏️", width=30, 
                    command=lambda c=campo_db, t=titulo_edicao, v=value: self.tela_edicao_modal(c, t, v)).grid(row=row, column=2, padx=(0, 20), pady=5, sticky="e")

    def tela_edicao_modal(self, campo_db: str, titulo_edicao: str, valor_atual: str):
        """
        Cria uma janela de topo (Toplevel) para a edição de um campo específico.
        """
        modal = ctk.CTkToplevel(self)
        modal.title(f"Editar {titulo_edicao}")
        modal.geometry("400x200")
        modal.transient(self) # Mantém a modal em cima da principal
        modal.grab_set() # Captura todos os eventos para a modal
        modal.resizable(False, False)

        ctk.CTkLabel(modal, text=f"Alterar {titulo_edicao}", font=("Arial", 18, "bold")).pack(pady=15)
        
        # O campo de entrada com o valor atual
        self.entry_edicao_valor = ctk.CTkEntry(modal, placeholder_text=f"Novo {titulo_edicao}", width=300)
        self.entry_edicao_valor.insert(0, valor_atual)
        self.entry_edicao_valor.pack(pady=5)

        # Botão de salvar
        ctk.CTkButton(modal, text="Salvar Alteração", fg_color="green",
                    command=lambda: self.salvar_edicao_perfil(modal, campo_db)).pack(pady=15)

    def salvar_edicao_perfil(self, modal: ctk.CTkToplevel, campo_db: str):
        """
        Salva a edição do campo no banco de dados e fecha o modal.
        """
        novo_valor = self.entry_edicao_valor.get()
        
        if not novo_valor or novo_valor.strip() == "":
            self.exibir_mensagem("Erro de Entrada", "O campo não pode ser vazio.", "erro")
            return

        try:
            # 1. Preparar os dados para o DB:
            
            dados_atualizacao = {
                'p_nome': None,
                'p_user_name': None,
                'p_email': None,
                'p_senha': None
            }
            
            # O campo_db (ex: 'nome') define qual valor será sobrescrito
            dados_atualizacao[f'p_{campo_db}'] = novo_valor

            # 2. Chamar a função do DB
            atualizar_perfil_cliente (
                curr_user_name=self.username,
                p_nome=dados_atualizacao['p_nome'],
                p_user_name=dados_atualizacao['p_user_name'],
                p_senha=dados_atualizacao['p_senha'], 
                p_email=dados_atualizacao['p_email']                
            )

            self.exibir_mensagem("Sucesso", f"O campo '{campo_db}' foi atualizado!", "sucesso")
            
            # Se alterou o username, atualiza o estado da aplicação e força logout
            if campo_db == 'user_name':
                self.exibir_mensagem("Atenção", "Seu nome de usuário foi alterado. Por favor, faça login novamente.", "info")
                modal.destroy()
                self.logout()
                return
                
            modal.destroy()
            self.tela_configuracao_usuario() # Recarrega a tela com os novos dados
            
        except Exception as e:
            self.exibir_mensagem("Erro de DB", f"Falha ao salvar: {str(e).split('\n')[0]}", "erro")

    def executar_busca_livros(self, termo: Optional[str] = None):
        """Busca livros e atualiza a exibição na tela do cliente."""
        
        if termo is None:
            termo = self.entry_busca_cliente.get()

        for widget in self.scroll_frame_livros.winfo_children():
            widget.destroy()

        try:
            resultados = buscar_livros(termo)
            
            header_frame = ctk.CTkFrame(self.scroll_frame_livros, fg_color="gray25")
            header_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=(5, 0))
            header_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)
            
            
            ctk.CTkLabel(header_frame, text="ID", font=("Arial", 14, "bold"), width=30).grid(row=0, column=0, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="ISBN", font=("Arial", 14, "bold"), width=120).grid(row=0, column=1, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Título", font=("Arial", 14, "bold"), width=250).grid(row=0, column=2, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Autor", font=("Arial", 14, "bold"), width=150).grid(row=0, column=3, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Disponíveis", font=("Arial", 14, "bold"), width=80).grid(row=0, column=4, padx=5, pady=5)
            
            
            if not resultados:
                ctk.CTkLabel(self.scroll_frame_livros, text="Nenhum livro encontrado.", font=("Arial", 16)).grid(row=1, column=0, padx=20, pady=20)
                return

            for i, livro in enumerate(resultados):
                # (id_livro, isbn, titulo, autor, num_copias, copias_disponiveis)
                copias_disponiveis = livro[5] 
                
                if(copias_disponiveis < 0): # Não mostra livros desativados
                    continue

                livro_frame = ctk.CTkFrame(self.scroll_frame_livros, fg_color=("gray85", "gray17"))
                livro_frame.grid(row=i + 1, column=0, sticky="ew", padx=5, pady=2)
                livro_frame.grid_columnconfigure((0, 1, 2, 3, 4), weight=1)
                                        
                cor_copias = "red" if copias_disponiveis <= 0 else "green"
                
                ctk.CTkLabel(livro_frame, text=livro[0], width=30).grid(row=0, column=0, padx=5, pady=5) # ID
                ctk.CTkLabel(livro_frame, text=livro[1], width=120).grid(row=0, column=1, padx=5, pady=5) # ISBN
                ctk.CTkLabel(livro_frame, text=livro[2], width=250, anchor="w").grid(row=0, column=2, padx=5, pady=5, sticky="w") # Título
                ctk.CTkLabel(livro_frame, text=livro[3], width=150, anchor="w").grid(row=0, column=3, padx=5, pady=5, sticky="w") # Autor
                
                ctk.CTkLabel(livro_frame, text=copias_disponiveis, text_color=cor_copias, width=80).grid(row=0, column=4, padx=5, pady=5) # Disponíveis
                
        except Exception as e:
            self.exibir_mensagem("Erro de Busca", f"Ocorreu um erro ao buscar livros: {e}", "erro")
            ctk.CTkLabel(self.scroll_frame_livros, text="Falha ao carregar o catálogo.", font=("Arial", 16)).grid(row=1, column=0, padx=20, pady=20)


    def tela_admin(self):
        """Tela principal para Administradores: Gerenciamento de Livros e Categorias."""
        self.limpar_tela()
        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(1, weight=1)

        # 1. Sidebar
        sidebar_frame = ctk.CTkFrame(self, width=140, corner_radius=0)
        sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew")
        sidebar_frame.grid_rowconfigure(7, weight=1) # CORREÇÃO: Aumenta o rowconfigure

        ctk.CTkLabel(sidebar_frame, text="👑 Admin", font=ctk.CTkFont(size=20, weight="bold")).grid(row=0, column=0, padx=20, pady=(20, 10))
        ctk.CTkLabel(sidebar_frame, text=f"Usuário: {self.username}", wraplength=100).grid(row=1, column=0, padx=20, pady=(0, 10))

        # Botões de navegação
        ctk.CTkButton(sidebar_frame, text="Gerenciar Livros", command=self.tela_gerenciar_livros).grid(row=2, column=0, padx=20, pady=10)
        ctk.CTkButton(sidebar_frame,text="Gerenciar Categorias",command=self.tela_adicionar_categoria).grid(row=3, column=0, padx=20, pady=10)
        
        # --- CORREÇÃO (Bug 3): Botão de Navegação Faltando ---
        ctk.CTkButton(sidebar_frame, text="🛒 Registrar Empréstimo", 
                      command=self.tela_emprestimo_livros).grid(row=4, column=0, padx=20, pady=10)
        
        ctk.CTkButton(sidebar_frame, text="Gerenciar Devoluções", 
                      command=self.tela_gerenciar_emprestimos).grid(row=5, column=0, padx=20, pady=10)
        
        # (Depois do botão "Gerenciar Devoluções")
        ctk.CTkButton(sidebar_frame, text="Gerir Clientes", 
                      command=self.tela_gerenciar_clientes).grid(row=6, column=0, padx=20, pady=10)
        
        # Mude o "Sair" para a linha 8
        ctk.CTkButton(sidebar_frame, text="Sair", fg_color="red", command=self.logout).grid(row=8, column=0, padx=20, pady=(10, 20))


        
        # Inicia na tela de Gerenciar Livros
        self.tela_gerenciar_livros()




    def tela_adicionar_categoria(self):
        # Limpa a área principal
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()
        
        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(3, weight=1) # Linha do scroll_frame

        # Título
        ctk.CTkLabel(main_frame, text="Gerenciamento de Categorias", font=ctk.CTkFont(size=20, weight="bold")).grid(row=0, column=0, pady=(0, 20), sticky="w")
        
        # --- Seção de Adicionar Nova Categoria ---
        add_frame = ctk.CTkFrame(main_frame)
        add_frame.grid(row=1, column=0, pady=10, sticky="ew")
        add_frame.grid_columnconfigure(0, weight=1)
        
        self.input_nova_categoria = ctk.CTkEntry(add_frame, placeholder_text="Nome da Nova Categoria")
        self.input_nova_categoria.grid(row=0, column=0, padx=10, pady=10, sticky="ew")
        
        ctk.CTkButton(add_frame, text="➕ Adicionar", command=self.adicionar_nova_categoria).grid(row=0, column=1, padx=10, pady=10)

        # --- Seção de Lista de Categorias ---
        self.lista_categorias_frame = ctk.CTkScrollableFrame(main_frame, label_text="Categorias Existentes")
        self.lista_categorias_frame.grid(row=3, column=0, sticky="nsew")
        self.lista_categorias_frame.grid_columnconfigure(0, weight=1)
        
        self.atualizar_lista_categorias()


    def adicionar_nova_categoria(self):
        """Função chamada pelo botão 'Adicionar'."""
        nome = self.input_nova_categoria.get().strip()
        
        if not nome:
            self.exibir_mensagem("Erro", "O nome da categoria não pode ser vazio.", "erro")
            return
            
        try:
            inserir_categoria(nome)
            self.input_nova_categoria.delete(0, 'end')
            self.atualizar_lista_categorias()
            self.exibir_mensagem("Sucesso", f"Categoria '{nome}' adicionada!", "info")
        except Exception as e:
            self.exibir_mensagem("Erro DB", f"Falha ao adicionar categoria:\n{e}", "erro")


    def atualizar_lista_categorias(self):
        """Busca as categorias no DB e as lista com botões de edição e exclusão."""
        
        for widget in self.lista_categorias_frame.winfo_children():
            widget.destroy()
            
        try:
            categorias = get_todas_categorias()
            
            if not categorias:
                ctk.CTkLabel(self.lista_categorias_frame, text="Nenhuma categoria encontrada.").grid(row=0, column=0, padx=10, pady=10)
                return

            for i, (id_cat, nome_cat) in enumerate(categorias):
                # Criar um frame para cada linha
                row_frame = ctk.CTkFrame(self.lista_categorias_frame, fg_color="transparent")
                row_frame.grid(row=i, column=0, padx=10, pady=(0, 5), sticky="ew")
                row_frame.grid_columnconfigure(0, weight=1) # Faz o label expandir
                
                ctk.CTkLabel(row_frame, text=f"ID {id_cat}: {nome_cat}", 
                             anchor="w").grid(row=0, column=0, pady=5, sticky="w")
                
                # Botão de Editar
                ctk.CTkButton(row_frame, text="✏️ Editar", width=70, fg_color="gray30",
                              command=lambda cid=id_cat, cnome=nome_cat: self.tela_edicao_categoria_modal(cid, cnome)
                             ).grid(row=0, column=1, pady=5, padx=(10, 5), sticky="e")
                
                # --- NOVO BOTÃO DE EXCLUIR ---
                ctk.CTkButton(row_frame, text="🚫 Excluir", width=70, fg_color="red",
                              command=lambda cid=id_cat, cnome=nome_cat: self.confirmar_delecao_categoria(cid, cnome)
                             ).grid(row=0, column=2, pady=5, padx=(0, 0), sticky="e")
                
        except Exception as e:
            ctk.CTkLabel(self.lista_categorias_frame, text=f"Erro ao carregar categorias: {e}", 
                         text_color="red").grid(row=0, column=0, padx=10, pady=10)
    
    def confirmar_delecao_categoria(self, id_categoria: int, nome: str):
        """Pede confirmação antes de excluir permanentemente uma categoria."""
        
        msg = CTkMessagebox(title="⚠️ CONFIRMAÇÃO DE EXCLUSÃO", 
                            message=f"Tem certeza que deseja EXCLUIR PERMANENTEMENTE a categoria:\n\n'{nome}' (ID: {id_categoria})?\n\nEsta ação não pode ser desfeita e irá remover a categoria de todos os livros associados.",
                            icon="warning", 
                            option_1="Cancelar", 
                            option_2="Excluir Permanentemente",
                            master=self)
        
        resposta = msg.get()

        if resposta == "Excluir Permanentemente":
            self.executar_delecao_categoria(id_categoria, nome)

    def executar_delecao_categoria(self, id_categoria: int, nome: str):
        """Chama a função de exclusão do banco de dados."""
        try:
            deletar_categoria(id_categoria)
            self.exibir_mensagem("Sucesso", f"Categoria '{nome}' excluída com sucesso!", "sucesso")
            self.atualizar_lista_categorias() # Atualiza a lista
            
        except Exception as e:
            self.exibir_mensagem("Erro DB", f"Falha ao excluir a categoria.\n{e}", "erro")

    def tela_edicao_categoria_modal(self, id_categoria: int, nome_atual: str):
        """
        Cria uma janela de topo (Toplevel) para a edição de uma categoria.
        (Baseado na tela_edicao_modal do perfil de usuário)
        """
        modal = ctk.CTkToplevel(self)
        modal.title("Editar Categoria")
        modal.geometry("400x200")
        modal.transient(self) 
        modal.grab_set() 
        modal.resizable(False, False)

        ctk.CTkLabel(modal, text=f"Editando Categoria (ID: {id_categoria})", font=("Arial", 18, "bold")).pack(pady=15)
        
        self.entry_edicao_categoria = ctk.CTkEntry(modal, width=300)
        self.entry_edicao_categoria.insert(0, nome_atual)
        self.entry_edicao_categoria.pack(pady=5)

        ctk.CTkButton(modal, text="Salvar Alteração", fg_color="green",
                    command=lambda: self.salvar_edicao_categoria(modal, id_categoria)).pack(pady=15)

    def salvar_edicao_categoria(self, modal: ctk.CTkToplevel, id_categoria: int):
        """
        Salva a edição da categoria no banco de dados e fecha o modal.
        """
        novo_nome = self.entry_edicao_categoria.get().strip()
        
        if not novo_nome:
            self.exibir_mensagem("Erro de Entrada", "O nome não pode ser vazio.", "erro")
            return

        try:
            # Chama a nova função do database.py
            editar_categoria(id_categoria, novo_nome)

            self.exibir_mensagem("Sucesso", "Categoria atualizada!", "sucesso")
            modal.destroy()
            self.atualizar_lista_categorias() # Recarrega a lista na tela principal
            
        except Exception as e:
            # O UNIQUE constraint do DB vai disparar um erro aqui
            self.exibir_mensagem("Erro de DB", f"Falha ao salvar: {str(e).split('\n')[0]}", "erro")

    def tela_gerenciar_livros(self):
        """Tela para CRUD de Livros do Administrador."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(2, weight=1) # CORREÇÃO: Linha do scroll_frame

        # Cabeçalho e Botão de Adicionar
        header_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        header_frame.grid(row=0, column=0, padx=0, pady=(0, 10), sticky="ew")
        header_frame.grid_columnconfigure(0, weight=1)
        
        ctk.CTkLabel(header_frame, text="📖 Gerenciar Livros", font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w")
        ctk.CTkButton(header_frame, text="➕ Adicionar Novo Livro", fg_color="green", command=self.tela_adicionar_livro).grid(row=0, column=1, sticky="e")
        
        # Frame de Pesquisa
        search_frame = ctk.CTkFrame(main_frame)
        search_frame.grid(row=1, column=0, sticky="ew", pady=(0, 10))
        search_frame.grid_columnconfigure(1, weight=1)

        ctk.CTkLabel(search_frame, text="Pesquisar Livros:").grid(row=0, column=0, padx=10, pady=10)
        self.entry_busca_admin = ctk.CTkEntry(search_frame, placeholder_text="Termo de Busca")
        self.entry_busca_admin.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        ctk.CTkButton(search_frame, text="Buscar 🔍", command=self.executar_busca_livros_admin).grid(row=0, column=2, padx=10, pady=10)

        # Frame de Exibição dos Resultados para Admin
        self.scroll_frame_livros_admin = ctk.CTkScrollableFrame(main_frame, label_text="Catálogo de Livros (Admin View)")
        self.scroll_frame_livros_admin.grid(row=2, column=0, padx=0, pady=(0, 0), sticky="nsew")
        self.scroll_frame_livros_admin.grid_columnconfigure(0, weight=1)

        self.executar_busca_livros_admin(termo="")


    def executar_busca_livros_admin(self, termo: Optional[str] = None):
        """Busca livros e atualiza a exibição na tela do administrador."""
        
        if termo is None:
            termo = self.entry_busca_admin.get()

        for widget in self.scroll_frame_livros_admin.winfo_children():
            widget.destroy()

        try:
            resultados = buscar_livros(termo)
            
            header_frame = ctk.CTkFrame(self.scroll_frame_livros_admin, fg_color="gray25")
            header_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=(5, 0))
            header_frame.grid_columnconfigure((0, 1, 2, 3, 4, 5), weight=1) 
            
            ctk.CTkLabel(header_frame, text="ID", font=("Arial", 14, "bold"), width=30).grid(row=0, column=0, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Título", font=("Arial", 14, "bold"), width=250).grid(row=0, column=1, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Autor", font=("Arial", 14, "bold"), width=150).grid(row=0, column=2, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Total Cóp.", font=("Arial", 14, "bold"), width=80).grid(row=0, column=3, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Disponíveis", font=("Arial", 14, "bold"), width=80).grid(row=0, column=4, padx=5, pady=5)
            ctk.CTkLabel(header_frame, text="Ações", font=("Arial", 14, "bold"), width=150).grid(row=0, column=5, padx=5, pady=5)
            
            if not resultados:
                ctk.CTkLabel(self.scroll_frame_livros_admin, text="Nenhum livro encontrado.", font=("Arial", 16)).grid(row=1, column=0, padx=20, pady=20)
                return

            for i, livro in enumerate(resultados):
                # (id_livro, isbn, titulo, autor, num_copias, copias_disponiveis)
                livro_frame = ctk.CTkFrame(self.scroll_frame_livros_admin, fg_color=("gray85", "gray17"))
                livro_frame.grid(row=i + 1, column=0, sticky="ew", padx=5, pady=2)
                livro_frame.grid_columnconfigure((0, 1, 2, 3, 4, 5), weight=1)
                
                ctk.CTkLabel(livro_frame, text=livro[0], width=30).grid(row=0, column=0, padx=5, pady=5) # ID
                ctk.CTkLabel(livro_frame, text=livro[2], width=250, anchor="w").grid(row=0, column=1, padx=5, pady=5, sticky="w") # Título
                ctk.CTkLabel(livro_frame, text=livro[3], width=150, anchor="w").grid(row=0, column=2, padx=5, pady=5, sticky="w") # Autor
                ctk.CTkLabel(livro_frame, text=livro[4], width=80).grid(row=0, column=3, padx=5, pady=5) # Total Cópias
                
                cor_copias = "red" if livro[5] <= 0 else "green"
                ctk.CTkLabel(livro_frame, text=livro[5], text_color=cor_copias, width=80).grid(row=0, column=4, padx=5, pady=5) # Disponíveis
                
                acoes_frame = ctk.CTkFrame(livro_frame, fg_color="transparent")
                acoes_frame.grid(row=0, column=5, padx=5, pady=5)
                ctk.CTkButton(acoes_frame, text="Editar", width=70, fg_color="gray30", 
                              command=lambda id_livro=livro[0]: self.tela_editar_livro(id_livro)).pack(side="left", padx=(0, 5))
                ctk.CTkButton(acoes_frame, text="Excluir", width=70, fg_color="red", 
                              command=lambda id_livro=livro[0]: self.confirmar_delecao_livro(id_livro)).pack(side="left")
                
        except Exception as e:
            self.exibir_mensagem("Erro de Busca", f"Ocorreu um erro ao buscar livros: {e}", "erro")
            ctk.CTkLabel(self.scroll_frame_livros_admin, text="Falha ao carregar o catálogo.", font=("Arial", 16)).grid(row=1, column=0, padx=20, pady=20)


    def tela_adicionar_livro(self):
        """Tela para o formulário de adição de um novo livro."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        
        ctk.CTkLabel(main_frame, text="➕ Adicionar Novo Livro", font=ctk.CTkFont(size=22, weight="bold")).pack(pady=10)
        
        form_frame = ctk.CTkFrame(main_frame)
        form_frame.pack(padx=20, pady=10, fill="x")
        
        self.entry_isbn = self.criar_campo_form(form_frame, "ISBN:", "978...")
        self.entry_titulo = self.criar_campo_form(form_frame, "Título:", "O Senhor dos Anéis")
        self.entry_autor = self.criar_campo_form(form_frame, "Autor:", "J.R.R. Tolkien")
        self.entry_editora = self.criar_campo_form(form_frame, "Editora:", "HarperCollins")
        self.entry_ano = self.criar_campo_form(form_frame, "Ano (YYYY-MM-DD):", "2001-01-01")
        self.entry_qtd_copias = self.criar_campo_form(form_frame, "Qtd. Cópias:", "5")
        
        ctk.CTkLabel(form_frame, text="IDs de Categoria (Separados por vírgula):").pack(pady=(10, 0))
        self.entry_categorias = ctk.CTkEntry(form_frame, placeholder_text="Ex: 1, 5, 8")
        self.entry_categorias.pack(pady=5, padx=20, fill="x")
        
        button_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        button_frame.pack(pady=20)
        ctk.CTkButton(button_frame, text="Salvar Livro", fg_color="green", command=self.salvar_novo_livro).pack(side="left", padx=10)
        ctk.CTkButton(button_frame, text="Voltar", fg_color="gray30", command=self.tela_gerenciar_livros).pack(side="left", padx=10)

    def criar_campo_form(self, master, label_text, placeholder):
        """Função auxiliar para criar um Label e um Entry de forma padronizada."""
        ctk.CTkLabel(master, text=label_text).pack(pady=(10, 0))
        entry = ctk.CTkEntry(master, placeholder_text=placeholder)
        entry.pack(pady=5, padx=20, fill="x")
        return entry
        
    def salvar_novo_livro(self):
        """Coleta dados do formulário e chama a função de inserção no DB."""
        
        try:
            isbn = int(self.entry_isbn.get())
            titulo = self.entry_titulo.get()
            autor = self.entry_autor.get()
            editora = self.entry_editora.get()
            ano = self.entry_ano.get() 
            qtd_copias = int(self.entry_qtd_copias.get())
            
            categorias_str = self.entry_categorias.get().replace(" ", "")
            if categorias_str:
                lista_de_categorias = [int(i) for i in categorias_str.split(',')]
            else:
                lista_de_categorias = []
                
        except ValueError:
            self.exibir_mensagem("Erro de Entrada", "Por favor, insira valores válidos para ISBN e Qtd. Cópias.", "erro")
            return
            
        if not all([titulo, autor, editora, ano]):
             self.exibir_mensagem("Erro de Entrada", "Preencha todos os campos obrigatórios.", "erro")
             return

        try:
            inserir_livro(isbn, titulo, autor, editora, ano, qtd_copias, lista_de_categorias)
            self.exibir_mensagem("Sucesso", f"Livro '{titulo}' inserido com sucesso!", "sucesso")
            self.tela_gerenciar_livros() # Volta para a lista
        except Exception as e:
            self.exibir_mensagem("Erro de Banco de Dados", str(e).split('\n')[0], "erro")

    
    def tela_editar_livro(self, id_livro: int):
        pass # Pendente

    def confirmar_delecao_livro(self, id_livro: int):
        """Abre uma caixa de diálogo para confirmar a exclusão do livro."""
        
        msg = CTkMessagebox(title="⚠️ Confirmação", 
                            message=f"Tem certeza que deseja DESATIVAR o livro ID: {id_livro}?",
                            icon="warning", 
                            option_1="Cancelar", 
                            option_2="Desativar",
                            master=self)
        
        resposta = msg.get()

        if resposta == "Desativar":
            self.desativar_livro_db(id_livro)
        
    def desativar_livro_db(self, id_livro: int):
        """Chama a função de desativar (soft delete) o livro no banco."""
        try:
            deletar_livro(id_livro) # A função 'deletar_livro' chama 'proc_desativar_livro'
            self.exibir_mensagem("Sucesso", f"Livro ID: {id_livro} desativado com sucesso!", "sucesso")
            self.tela_gerenciar_livros() # Atualiza a lista
            
        except Exception as e:
            self.exibir_mensagem("Erro DB", f"Falha ao desativar o livro ID: {id_livro}.\n{e}", "erro")
    
    def logout(self):
        """Faz o logout do usuário e retorna para a tela de login."""
        self.user_type = None
        self.username = None
        self.emprestimos_atuais = 0
        self.exibir_mensagem("Logout", "Você saiu do sistema.", "info")
        self.tela_login()

    def emprestar_livro(self, id_livro: int, titulo: str):
        """Lógica para o ADMIN registrar o empréstimo para um CLIENTE."""
        
        cliente_alvo = self.entry_cliente_emprestimo.get()
        
        if not cliente_alvo:
            self.exibir_mensagem("Erro", "Por favor, digite o nome de usuário do cliente.", "erro")
            return

        msg = CTkMessagebox(title="Confirmação de Empréstimo", 
                            message=f"Confirmar empréstimo do livro:\n'{titulo}'\n\nPARA O CLIENTE: {cliente_alvo}?",
                            icon="question", 
                            option_1="Cancelar", 
                            option_2="Confirmar",
                            master=self)
        
        resposta = msg.get()

        if resposta == "Confirmar":
            try:
                # O Admin logado (self.username) registra para o cliente (cliente_alvo)
                registrar_emprestimo_admin(
                    admin_username=self.username, 
                    cliente_username=cliente_alvo,
                    id_livro=id_livro 
                )
                
                self.exibir_mensagem("Sucesso", f"Empréstimo do livro '{titulo}' registrado para {cliente_alvo}!", "sucesso")
                
                # Recarregar a lista
                self.executar_busca_emprestimo(termo="")
                
            except Exception as e:
                self.exibir_mensagem("Erro de Empréstimo", f"Falha ao registrar empréstimo:\n{e}", "erro")

    # Em main.py

    def tela_editar_livro(self, id_livro: int):
        """
        Tela para o formulário de EDIÇÃO de um livro (com barra de rolagem).
        """
        
        try:
            detalhes = get_detalhes_livro(id_livro) 
            if not detalhes:
                self.exibir_mensagem("Erro", f"Não foi possível encontrar o livro ID: {id_livro}", "erro")
                return
        except Exception as e:
            self.exibir_mensagem("Erro de DB", f"Falha ao buscar detalhes do livro:\n{e}", "erro")
            return

        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        main_frame.grid_rowconfigure(1, weight=1) # CORREÇÃO: Faz a linha do scroll expandir
        
        ctk.CTkLabel(main_frame, text=f"✏️ Editando Livro (ID: {id_livro})", 
                     font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, pady=10)
        
        # --- CORREÇÃO: O form_frame agora é um CTkScrollableFrame ---
        form_frame = ctk.CTkScrollableFrame(main_frame)
        form_frame.grid(row=1, column=0, padx=20, pady=10, sticky="nsew")
        form_frame.grid_columnconfigure(0, weight=1)

        # 3. Criar e Pré-preencher os campos
        self.entry_isbn = self.criar_campo_form(form_frame, "ISBN:", "978...")
        self.entry_isbn.insert(0, detalhes['isbn'])

        self.entry_titulo = self.criar_campo_form(form_frame, "Título:", "O Senhor dos Anéis")
        self.entry_titulo.insert(0, detalhes['titulo'])

        self.entry_autor = self.criar_campo_form(form_frame, "Autor:", "J.R.R. Tolkien")
        self.entry_autor.insert(0, detalhes['autor'])

        self.entry_editora = self.criar_campo_form(form_frame, "Editora:", "HarperCollins")
        self.entry_editora.insert(0, detalhes['editora'])

        self.entry_ano = self.criar_campo_form(form_frame, "Ano (YYYY-MM-DD):", "2001-01-01")
        self.entry_ano.insert(0, str(detalhes['ano']))

        self.entry_qtd_copias = self.criar_campo_form(form_frame, "Qtd. Cópias:", "5")
        self.entry_qtd_copias.insert(0, detalhes['qtd_copias'])
        
        nomes_categorias_atuais = ", ".join(detalhes['categorias']) if detalhes['categorias'] else "Nenhuma"
        ctk.CTkLabel(form_frame, text=f"Categorias Atuais: {nomes_categorias_atuais}", font=("Arial", 12, "italic")).pack(pady=(10, 0))

        ctk.CTkLabel(form_frame, text="IDs de Categoria (Separados por vírgula):").pack(pady=(10, 0))
        self.entry_categorias = ctk.CTkEntry(form_frame, placeholder_text="Deixe em branco para NÃO alterar")
        self.entry_categorias.pack(pady=5, padx=20, fill="x")
        
        # --- CORREÇÃO: Botões ficam FORA da rolagem, na linha 2 ---
        button_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        button_frame.grid(row=2, column=0, pady=20)
        
        ctk.CTkButton(button_frame, text="Salvar Alterações", fg_color="green", 
                      command=lambda: self.salvar_edicao_livro(id_livro)).pack(side="left", padx=10)
        
        ctk.CTkButton(button_frame, text="Voltar", fg_color="gray30", 
                      command=self.tela_gerenciar_livros).pack(side="left", padx=10)


    def salvar_edicao_livro(self, id_livro: int):
        """Coleta dados do formulário de EDIÇÃO e chama a função de ATUALIZAÇÃO no DB."""
        
        try:
            # 1. Coletar todos os dados
            isbn = int(self.entry_isbn.get())
            titulo = self.entry_titulo.get()
            autor = self.entry_autor.get()
            editora = self.entry_editora.get()
            ano = self.entry_ano.get()
            qtd_copias = int(self.entry_qtd_copias.get())
            
            # 2. Lógica das Categorias
            categorias_str = self.entry_categorias.get().replace(" ", "")
            
            if categorias_str:
                # Se o usuário digitou algo, converte para lista de INTs
                lista_de_categorias = [int(i) for i in categorias_str.split(',')]
            else:
                # Se o usuário deixou em branco, passa None
                # O SQL (IS NOT NULL) vai ignorar isso e manter as categorias antigas
                lista_de_categorias = None 
                
        except ValueError:
            self.exibir_mensagem("Erro de Entrada", "Por favor, insira valores válidos para ISBN e Qtd. Cópias.", "erro")
            return
            
        if not all([titulo, autor, editora, ano]):
             self.exibir_mensagem("Erro de Entrada", "Preencha todos os campos obrigatórios.", "erro")
             return

        try:
            # 3. Chamar a função de ATUALIZAR do database.py
            atualizar_livro(
                id_livro, 
                isbn, 
                titulo, 
                autor, 
                editora, 
                ano, 
                qtd_copias, 
                lista_de_categorias
            )
            
            self.exibir_mensagem("Sucesso", f"Livro '{titulo}' (ID: {id_livro}) atualizado!", "sucesso")
            self.tela_gerenciar_livros() # Volta para a lista
            
        except Exception as e:
            self.exibir_mensagem("Erro de Banco de Dados", str(e).split('\n')[0], "erro")

    def tela_gerenciar_clientes(self):
        """Tela para o Admin pesquisar e gerenciar um cliente."""
        
        for widget in self.winfo_children():
            if int(widget.grid_info().get('column', -1)) == 1:
                widget.destroy()

        main_frame = ctk.CTkFrame(self)
        main_frame.grid(row=0, column=1, padx=20, pady=(20, 20), sticky="nsew", rowspan=4)
        main_frame.grid_columnconfigure(0, weight=1)
        
        ctk.CTkLabel(main_frame, text="👤 Gerenciar Clientes", 
                     font=ctk.CTkFont(size=22, weight="bold")).grid(row=0, column=0, sticky="w", pady=(0, 10))

        # --- Frame de Pesquisa ---
        search_frame = ctk.CTkFrame(main_frame)
        search_frame.grid(row=1, column=0, sticky="ew", pady=(10, 10))
        search_frame.grid_columnconfigure(1, weight=1)
        
        ctk.CTkLabel(search_frame, text="Usuário do Cliente:", 
                     font=ctk.CTkFont(weight="bold")).grid(row=0, column=0, padx=10, pady=10)
        self.entry_busca_cliente_admin = ctk.CTkEntry(search_frame, placeholder_text="Digite o user_name do cliente")
        self.entry_busca_cliente_admin.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        
        ctk.CTkButton(search_frame, text="Buscar 🔍", 
                      command=self.buscar_cliente_admin).grid(row=0, column=2, padx=10, pady=10)
        
        # --- BOTÃO CADASTRO CLIENTE ---
        ctk.CTkButton(search_frame, text="Cadastrar Novo +",
              fg_color="green",
              command=self.navegar_para_cadastro_admin).grid(row=0, column=3, padx=(10, 10), pady=10)
        # --------------------
        
        # --- Frame de Resultado ---
        self.frame_cliente_resultado = ctk.CTkFrame(main_frame, fg_color="gray25")
        self.frame_cliente_resultado.grid(row=2, column=0, sticky="ew", pady=(10, 10))
        self.frame_cliente_resultado.grid_columnconfigure(1, weight=1)
        self.frame_cliente_resultado.grid_remove() 


    def buscar_cliente_admin(self):
        """Busca o cliente e exibe os resultados e botões de ação."""
        
        username_cliente = self.entry_busca_cliente_admin.get()
        if not username_cliente:
            self.exibir_mensagem("Erro", "Digite um nome de usuário para buscar.", "erro")
            return
            
        # Limpa o frame de resultados anterior
        for widget in self.frame_cliente_resultado.winfo_children():
            widget.destroy()

        try:
            # Reutiliza a função get_dados_usuario
            dados = get_dados_usuario(username_cliente)
            
            if not dados or dados[3] != 'cliente': # Garante que é um cliente
                self.exibir_mensagem("Info", f"Cliente '{username_cliente}' não encontrado.", "info")
                self.frame_cliente_resultado.grid_remove()
                return

            _, nome, username, _, email = dados
            
            # Mostra o frame
            self.frame_cliente_resultado.grid()
            
            # Exibe os dados
            ctk.CTkLabel(self.frame_cliente_resultado, text=f"Nome: {nome}", anchor="w").grid(row=0, column=0, columnspan=2, padx=10, pady=5, sticky="ew")
            ctk.CTkLabel(self.frame_cliente_resultado, text=f"Username: {username}", anchor="w").grid(row=1, column=0, columnspan=2, padx=10, pady=5, sticky="ew")
            ctk.CTkLabel(self.frame_cliente_resultado, text=f"Email: {email}", anchor="w").grid(row=2, column=0, columnspan=2, padx=10, pady=5, sticky="ew")

            # Botões de Ação
            btn_frame = ctk.CTkFrame(self.frame_cliente_resultado, fg_color="transparent")
            btn_frame.grid(row=3, column=0, columnspan=2, padx=10, pady=10)
            
            # O "Editar" reutiliza a MESMA tela modal que o cliente usa!
            ctk.CTkButton(btn_frame, text="✏️ Editar Perfil", fg_color="gray30",
                          command=lambda u=username, n=nome, e=email: self.tela_edicao_modal_admin(u, n, e)).pack(side="left", padx=10)
            
            ctk.CTkButton(btn_frame, text="🚫 Desativar Cliente", fg_color="red",
                          command=lambda u=username: self.confirmar_desativar_cliente(u)).pack(side="left", padx=10)

        except Exception as e:
            self.exibir_mensagem("Erro de Busca", str(e).split('\n')[0], "erro")
            self.frame_cliente_resultado.grid_remove()

    def tela_edicao_modal_admin(self, username_cliente: str, nome_atual: str, email_atual: str):
        """
        Modal para o ADMIN editar o perfil do CLIENTE.
        (Esta é uma CÓPIA da tela_edicao_modal, mas adaptada para o Admin)
        """
        modal = ctk.CTkToplevel(self)
        modal.title(f"Editando {username_cliente}")
        modal.geometry("400x300")
        modal.transient(self)
        modal.grab_set()
        modal.resizable(False, False)

        ctk.CTkLabel(modal, text=f"Alterar Nome de {username_cliente}", font=("Arial", 16, "bold")).pack(pady=(15,0))
        entry_nome = ctk.CTkEntry(modal, width=300)
        entry_nome.insert(0, nome_atual)
        entry_nome.pack(pady=5)
        
        ctk.CTkLabel(modal, text=f"Alterar Email de {username_cliente}", font=("Arial", 16, "bold")).pack(pady=(15,0))
        entry_email = ctk.CTkEntry(modal, width=300)
        entry_email.insert(0, email_atual)
        entry_email.pack(pady=5)

        # O Admin não pode (e não deve) alterar o username ou senha do cliente por aqui.
        # Se precisar alterar o username, a tela teria que ser mais complexa.

        ctk.CTkButton(modal, text="Salvar Alterações", fg_color="green",
                    command=lambda: self.salvar_edicao_admin(modal, username_cliente, entry_nome.get(), entry_email.get())).pack(pady=20)

    def salvar_edicao_admin(self, modal: ctk.CTkToplevel, username_cliente: str, novo_nome: str, novo_email: str):
        """ Salva as alterações feitas pelo Admin no perfil do Cliente. """
        try:
            # Reutiliza a função 'atualizar_perfil_cliente'
            atualizar_perfil_cliente(
                curr_user_name=username_cliente,
                p_nome=novo_nome,
                p_user_name=None, # Admin não altera username
                p_email=novo_email,
                p_senha=None # Admin não altera senha
            )
            self.exibir_mensagem("Sucesso", f"Perfil de {username_cliente} atualizado!", "sucesso")
            modal.destroy()
            self.buscar_cliente_admin() # Recarrega os dados na tela
            
        except Exception as e:
            self.exibir_mensagem("Erro de DB", f"Falha ao salvar: {str(e).split('\n')[0]}", "erro")


    def confirmar_desativar_cliente(self, username_cliente: str):
        """ Pede confirmação antes de desativar (soft delete) um cliente. """
        
        msg = CTkMessagebox(title="⚠️ Confirmação", 
                            message=f"Tem certeza que deseja DESATIVAR o cliente '{username_cliente}'?\n\nEsta ação não pode ser desfeita.",
                            icon="warning", 
                            option_1="Cancelar", 
                            option_2="Desativar",
                            master=self)
        
        resposta = msg.get()

        if resposta == "Desativar":
            try:
                # Chama a nova função do database.py
                desativar_cliente(username_cliente)
                self.exibir_mensagem("Sucesso", f"Cliente '{username_cliente}' foi desativado.", "sucesso")
                self.frame_cliente_resultado.grid_remove() # Limpa o resultado
            except Exception as e:
                 self.exibir_mensagem("Erro de DB", f"Falha ao desativar: {str(e).split('\n')[0]}", "erro")
if __name__ == "__main__":
    app = App()
    app.mainloop()