import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import fitz  # PyMuPDF
import traceback

# Carregar o tokenizer e o modelo
tokenizer = AutoTokenizer.from_pretrained("Locutusque/gpt2-xl-conversational")
model = AutoModelForCausalLM.from_pretrained("Locutusque/gpt2-xl-conversational")

# Variável global para armazenar o conteúdo do PDF
pdf_content = ""

# Função para ler o PDF
def read_pdf(file_path):
    try:
        doc = fitz.open(file_path)
        text = ""
        for page_num in range(len(doc)):
            page = doc.load_page(page_num)
            text += page.get_text()
        return text
    except Exception as e:
        print(f"Erro ao ler o PDF: {e}")
        print(traceback.format_exc())
        return ""

# Função para carregar o PDF e armazenar o conteúdo
def load_pdf(pdf_file):
    global pdf_content
    try:
        pdf_path = pdf_file.name  # Acessar o caminho do arquivo carregado
        pdf_content = read_pdf(pdf_path)
        if pdf_content:
            return "PDF carregado com sucesso!"
        else:
            return "Falha ao carregar o PDF."
    except Exception as e:
        print(f"Erro ao carregar o PDF: {e}")
        print(traceback.format_exc())
        return "Erro ao carregar o PDF."

# Função para responder perguntas com base no conteúdo do PDF
def answer_question(question, max_length=200, temperature=0.7, top_k=50, top_p=0.95):
    global pdf_content
    try:
        if not pdf_content:
            return "Por favor, carregue um PDF primeiro.", ""
        
        # Limitar o tamanho do conteúdo do PDF para evitar exceder o número máximo de tokens
        max_tokens = 1024  # O número máximo de tokens permitido para o GPT-2 é geralmente 1024
        truncated_content = pdf_content[:max_tokens]

        prompt = f"Conteúdo do PDF: {truncated_content}\nPergunta: {question}\nResposta em português:"

        # Verificando o tamanho do prompt
        print(f"Prompt gerado (tamanho {len(prompt)}):\n{prompt[:500]}...")  # Imprime os primeiros 500 caracteres para depuração

        # Tokenizando o prompt
        inputs = tokenizer(prompt, return_tensors="pt")
        print(f"Tokens de entrada: {inputs.input_ids.shape[1]} tokens")  # Verifica o número de tokens

        # Gerar a resposta
        outputs = model.generate(
            inputs.input_ids,
            max_length=max_length,
            temperature=temperature,
            top_k=top_k,
            top_p=top_p,
            num_return_sequences=1
        )

        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        return response, prompt
    except Exception as e:
        print(f"Erro ao gerar resposta: {e}")
        print(traceback.format_exc())
        return "Erro ao gerar resposta.", ""

# Interface do Gradio para carregar PDF e fazer perguntas
pdf_loader = gr.Interface(
    fn=load_pdf,
    inputs=gr.File(label="Carregue um PDF"),
    outputs="text",
    title="Carregar PDF"
)

question_answerer = gr.Interface(
    fn=answer_question,
    inputs=gr.Textbox(lines=2, label="Pergunta"),
    outputs=[gr.Textbox(label="Resposta"), gr.Textbox(label="Prompt usado")],
    title="Perguntas sobre o PDF"
)

# Combinar as interfaces em uma aplicação
iface = gr.TabbedInterface(
    [pdf_loader, question_answerer],
    ["Carregar PDF", "Fazer Perguntas"]
)

if __name__ == "__main__":
    iface.launch()