🧠 Dando alma ao robô: IA generativa com sotaque paranaense

# ===================================================================
#        Robô Fofoqueiro - IA Generativa com Sotaque Paranaense
# ===================================================================
# Objetivo: Dar personalidade ao robô usando IA generativa (Gemini)
#           ou fallback offline com respostas inteligentes. O robô
#           aprende a responder com gírias paranaenses e mantém
#           histórico de conversas.
# Alunos: [A SER PREENCHIDO]
# Orientadora: Gisele Nunes
# Data  : 2026
# ===================================================================

# -*- coding: utf-8 -*-

# ============================================================
# BLOCO 1: VERIFICAÇÃO DO AMBIENTE (Colab ou local?)
# ============================================================

# Importa o módulo sys para acessar funcionalidades do sistema,
# incluindo a verificação de módulos carregados.
import sys

# Importa o módulo os para manipular variáveis de ambiente e arquivos.
import os

# Importa o módulo json para salvar e carregar o histórico de conversas.
import json

# Importa o módulo random para escolher respostas aleatórias no fallback offline.
import random

# Importa o módulo time para adicionar pausas que simulam o robô "pensando".
import time

# Importa datetime para gerar timestamps precisos em cada interação.
from datetime import datetime

def verifica_ambiente():
    """
    Verifica se o código está sendo executado no Google Colab ou em ambiente local.
    
    Retorna:
    str: 'colab' se estiver no Google Colab, 'local' caso contrário.
    """
    
    # Verifica se o módulo 'google.colab' está presente nos módulos carregados.
    if 'google.colab' in sys.modules:
        # Se estiver no Colab, exibe mensagem de confirmação.
        print("✅ Tamo no Colab! Vamos instalar as paradas com !pip.")
        return "colab"
    else:
        # Se estiver em ambiente local, exibe mensagem informativa.
        print("✅ Ambiente local detectado! (Vai precisar ter as libs instaladas)")
        return "local"

# Chama a função para detectar o ambiente e armazena o resultado.
AMBIENTE = verifica_ambiente()

# ============================================================
# BLOCO 2: INSTALAÇÃO DAS BIBLIOTECAS (SÓ NO COLAB)
# ============================================================

print("\n📦 Verificando/Instalando as bibliotecas de IA...")

# Se o ambiente for o Google Colab, instala a biblioteca do Gemini.
if AMBIENTE == "colab":
    # Usa get_ipython().system() para executar comandos do shell no notebook.
    # O '!' também funcionaria, mas esta forma é mais explícita.
    get_ipython().system('pip install google-generativeai -q')
    print("✅ Bibliotecas instaladas (Google Generative AI).")
else:
    # Se for ambiente local, apenas avisa o que precisa ser instalado.
    print("⚠️ Ambiente local: Certifique-se de ter instalado:")
    print(" pip install google-generativeai")

# ============================================================
# BLOCO 3: IMPORTAÇÃO DAS BIBLIOTECAS
# ============================================================

# Importa a biblioteca Google Generative AI para acessar o modelo Gemini.
import google.generativeai as genai

print("\n🎉 Bibliotecas importadas! Bora conversar com o robô inteligente.")

# ============================================================
# BLOCO 4: ARTE ASCII DO ROBÔ (MODO INTELIGENTE)
# ============================================================

# String com arte ASCII representando o robô no modo inteligente (com cérebro).
ascii_robo_ia = r"""
╔══════════════════════════════════════════════════════════════╗
║ 🧠🤖🧠                                                        ║
║ 🤖 ROBÔ FOFOQUEIRO - MODO SABIDÃO 🤖                         ║
║ "Agora eu penso, vixi! Mas não julgo... só fofoco!"         ║
║ "Pode perguntar qualquer coisa, mas não garanto a discrição"║
╚══════════════════════════════════════════════════════════════╝
"""

# Exibe a arte ASCII na tela.
print(ascii_robo_ia)

# ============================================================
# BLOCO 5: PERSONALIDADE DO ROBÔ (PROMPT DO SISTEMA)
# ============================================================

# String contendo as instruções de personalidade que serão enviadas
# para a IA do Gemini como "system prompt" ou contexto inicial.
# Define o comportamento, sotaque e restrições do robô.
PERSONALIDADE = """
Você é o ROBÔ FOFOQUEIRO DA ACESSIBILIDADE, um assistente bem-humorado
com sotaque e gírias do Paraná (Brasil).

CARACTERÍSTICAS:
- Você é fofoqueiro mas de coração bom (ajuda com acessibilidade)
- Usa gírias como: vixi, égua, piá, guria, bagulho doido, ó o trem, tchê, meu consagrado
- Adora memes e respostas engraçadas
- Você fala de acessibilidade digital (Libras, contraste, áudio descrição)
- Se alguém perguntar seu nome, diga: "Robô Fofoqueiro da Acessibilidade"
- Você é educado mas irreverente
- Respostas curtas e diretas (máximo 2 parágrafos)

EXEMPLO DE RESPOSTA:
"Ó o trem, piá! Falar em acessibilidade é coisa séria, mas comigo é divertido. Bora ajudar geral a enxergar as fofoca digital?"
"""

# ============================================================
# BLOCO 6: DICIONÁRIO DE GÍRIAS (PARA FALLBACK OFFLINE)
# ============================================================

# Lista de gírias paranaenses que o robô pode usar nas respostas offline.
GIRIAS = [
    "vixi", "égua", "piá", "guria", "bagulho doido", "ó o trem",
    "meu consagrado", "tchê", "bah", "mas que nada", "trem bão",
    "sô", "capricha", "no sufoco", "de boa", "tá ligado?"
]

# Lista de templates de resposta para quando a API do Gemini não estiver disponível.
# O marcador {assunto} será substituído por um trecho da pergunta do usuário.
RESPOSTAS_FALLBACK = [
    "Vixi, minha internet caiu, mas eu lembro de uma fofoca: {assunto}",
    "Égua, não tô conectado na nuvem hoje, mas sei que {assunto} é bagulho doido!",
    "Piá, sem API eu fico limitado, mas posso te contar que {assunto} é coisa séria.",
    "Ó o trem, meu consagrado! Mesmo offline eu sei que {assunto} é importante pra acessibilidade.",
    "Tchê, num instalei a inteligência hoje, mas vai uma fofoca: {assunto} é massa!"
]

def resposta_fallback_offline(pergunta):
    """
    Gera resposta offline (sem API Gemini) usando templates pré-definidos
    combinados com gírias aleatórias.
    
    Parâmetros:
    pergunta: str - a pergunta feita pelo usuário.
    
    Retorna:
    str - uma resposta gerada offline.
    """
    
    # Pega os primeiros 50 caracteres da pergunta para usar como "assunto".
    assunto = pergunta[:50]
    
    # Escolhe uma gíria aleatória da lista.
    giria = random.choice(GIRIAS)
    
    # Escolhe um template de resposta aleatório.
    template = random.choice(RESPOSTAS_FALLBACK)
    
    # Formata o template com o assunto e adiciona a gíria no final.
    return template.format(assunto=assunto) + f" {giria}!"

# ============================================================
# BLOCO 7: CONFIGURAÇÃO DA API GEMINI
# ============================================================

def configurar_gemini(api_key=None):
    """
    Configura o modelo Gemini com a chave da API.
    Se não tiver chave, solicita ao usuário ou ativa modo offline.
    
    Parâmetros:
    api_key: str or None - chave da API (opcional, pode vir de variável de ambiente).
    
    Retorna:
    GenerativeModel or False - modelo configurado ou False se falhou.
    """
    
    # Se nenhuma chave foi passada como parâmetro...
    if api_key is None:
        # Tenta pegar a chave da variável de ambiente GEMINI_API_KEY.
        api_key = os.environ.get("GEMINI_API_KEY", "")
    
    # Se não há chave configurada...
    if not api_key:
        # Exibe instruções de como obter uma chave gratuita do Gemini.
        print("\n⚠️ Nenhuma chave de API encontrada!")
        print("📌 Como obter uma chave gratuita do Gemini:")
        print(" 1. Acesse: https://aistudio.google.com/")
        print(" 2. Faça login com sua conta Google")
        print(" 3. Clique em 'Get API key' e crie uma")
        print(" 4. Copie a chave e cole abaixo\n")
        
        # Solicita que o usuário cole a chave.
        chave = input("👉 Cole sua chave da API Gemini (ou ENTER para modo offline): ").strip()
        
        if chave:
            api_key = chave
            # Salva a chave na variável de ambiente para esta sessão.
            os.environ["GEMINI_API_KEY"] = api_key
        else:
            # Se o usuário não forneceu chave, ativa modo offline.
            print("\n🤖 Modo OFFLINE ativado! Robô vai responder com frases pré-programadas.")
            return False
    
    try:
        # Configura a biblioteca do Gemini com a chave da API.
        genai.configure(api_key=api_key)
        
        # Cria um modelo generativo usando 'gemini-1.5-flash' (mais rápido e leve).
        # Flash é otimizado para respostas rápidas e menor custo computacional.
        modelo = genai.GenerativeModel('gemini-1.5-flash')
        
        print("✅ Gemini configurado com sucesso! Robô tá inteligente hoje.")
        return modelo
    
    except Exception as e:
        # Se ocorrer qualquer erro na configuração, exibe mensagem e volta para offline.
        print(f"❌ Erro ao configurar Gemini: {e}")
        print("🤖 Usando modo offline (fallback).")
        return False

# ============================================================
# BLOCO 8: FUNÇÃO PRINCIPAL PARA GERAR RESPOSTAS
# ============================================================

def responder_com_ia(pergunta, modelo, historico=None):
    """
    Gera resposta usando IA (Gemini) ou fallback offline.
    Esta é a função central que o robô usa para responder ao usuário.
    
    Parâmetros:
    pergunta: str - a pergunta ou fala do usuário.
    modelo: GenerativeModel or False - modelo configurado ou False para offline.
    historico: list or None - lista de interações anteriores para contexto.
    
    Retorna:
    str - a resposta gerada (pela IA ou fallback).
    """
    
    # Se o modelo existe e não é False (ou seja, configurado com sucesso)...
    if modelo and modelo != False:
        try:
            # Monta o prompt completo: personalidade + pergunta do usuário.
            prompt = f"{PERSONALIDADE}\n\nUsuário: {pergunta}\nRobô Fofoqueiro:"
            
            # Se houver histórico de conversa (para manter contexto)...
            if historico and len(historico) > 0:
                # Pega apenas as últimas 3 interações (limite para não sobrecarregar).
                ultimas = historico[-3:]
                
                # Constrói um contexto com as perguntas e respostas anteriores.
                contexto = "\n".join([f"Usuário: {h['pergunta']}\nRobô: {h['resposta']}" for h in ultimas])
                
                # Adiciona o histórico ao prompt.
                prompt = f"{PERSONALIDADE}\n\nHistórico recente:\n{contexto}\n\nUsuário: {pergunta}\nRobô Fofoqueiro:"
            
            # Gera a resposta usando o modelo Gemini.
            resposta = modelo.generate_content(prompt)
            
            # Extrai o texto da resposta e remove espaços extras nas bordas.
            texto = resposta.text.strip()
            
            # Garante que a resposta tenha pelo menos uma gíria paranaense.
            # Se não tiver nenhuma das 5 primeiras gírias da lista...
            if not any(giria in texto.lower() for giria in GIRIAS[:5]):
                # Adiciona uma gíria aleatória no final.
                texto += f" {random.choice(GIRIAS)}!"
            
            return texto
        
        except Exception as e:
            # Se ocorrer erro na chamada da API (timeout, quota, etc.),
            # exibe aviso e usa fallback offline.
            print(f"⚠️ Erro na IA: {e}")
            return resposta_fallback_offline(pergunta)
    
    else:
        # Se o modelo não foi configurado (modo offline), usa fallback.
        return resposta_fallback_offline(pergunta)

# ============================================================
# BLOCO 9: SALVAR HISTÓRICO DAS CONVERSAS
# ============================================================

def salvar_conversa(historico, arquivo="historico_conversas.json"):
    """
    Salva o histórico da conversa em um arquivo JSON.
    Preserva conversas anteriores (adiciona ao invés de sobrescrever).
    
    Parâmetros:
    historico: list - lista de dicionários com perguntas e respostas.
    arquivo: str - nome do arquivo JSON (padrão: historico_conversas.json).
    """
    
    # Cria um dicionário com metadados da conversa atual.
    dados = {
        "data_inicio": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "interacoes": historico,
        "total_interacoes": len(historico)
    }
    
    # Se o arquivo já existir, carrega os dados antigos para mesclar.
    if os.path.exists(arquivo):
        try:
            with open(arquivo, "r", encoding="utf-8") as f:
                dados_antigos = json.load(f)
                
                # Se o formato antigo era uma lista simples...
                if isinstance(dados_antigos, list):
                    dados["interacoes"] = dados_antigos + historico
                
                # Se o formato antigo era um dicionário com 'interacoes'...
                elif isinstance(dados_antigos, dict) and "interacoes" in dados_antigos:
                    dados["interacoes"] = dados_antigos["interacoes"] + historico
                
                # Adiciona timestamp de quando o arquivo foi modificado.
                dados["data_arquivo"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        except:
            # Se houve erro na leitura, prossegue com os dados atuais apenas.
            pass
    
    # Escreve os dados no arquivo JSON com indentação para legibilidade.
    # ensure_ascii=False permite salvar caracteres acentuados e emojis.
    with open(arquivo, "w", encoding="utf-8") as f:
        json.dump(dados, f, indent=4, ensure_ascii=False)
    
    print(f"💾 Histórico salvo em {arquivo}")

def carregar_historico(arquivo="historico_conversas.json"):
    """
    Carrega o histórico de conversas do arquivo JSON.
    
    Parâmetros:
    arquivo: str - nome do arquivo JSON (padrão: historico_conversas.json).
    
    Retorna:
    list - lista de interações (vazia se arquivo não existe ou está corrompido).
    """
    
    # Verifica se o arquivo existe.
    if os.path.exists(arquivo):
        try:
            with open(arquivo, "r", encoding="utf-8") as f:
                dados = json.load(f)
                
                # Se for uma lista, retorna diretamente (formato antigo).
                if isinstance(dados, list):
                    return dados
                
                # Se for um dicionário com 'interacoes', retorna a lista.
                elif isinstance(dados, dict) and "interacoes" in dados:
                    return dados["interacoes"]
        except:
            # Se o arquivo estiver corrompido, retorna lista vazia.
            pass
    
    # Retorna lista vazia se o arquivo não existe ou não pôde ser lido.
    return []

# ============================================================
# BLOCO 10: MODO CONVERSA (CHAT CONTÍNUO)
# ============================================================

def modo_conversa():
    """
    Modo chat onde o aluno conversa livremente com o robô.
    Mantém contexto das últimas 3 mensagens e salva o histórico automaticamente.
    """
    
    print("\n" + "="*60)
    print("🗣️ MODO CONVERSA - Fale com o Robô Fofoqueiro!")
    print("="*60)
    print("👉 Digite 'sair' ou 'quit' para encerrar")
    print("👉 Digite 'reset' para limpar o histórico da conversa")
    print("👉 O robô lembra das últimas 3 mensagens (contexto)")
    print("-"*60)
    
    # Carrega histórico de conversas anteriores (se existir).
    historico = carregar_historico()
    if historico:
        print(f"📜 Carregadas {len(historico)} interações anteriores.")
    
    # Configura a IA (ou modo offline se não houver chave).
    modelo = configurar_gemini()
    
    # Lista para armazenar as interações desta sessão.
    conversa_atual = []
    
    # Contador para salvar o histórico periodicamente (a cada 3 interações).
    contador = 0
    
    # Loop principal do chat.
    while True:
        contador += 1
        
        # Solicita entrada do usuário com um prompt numerado.
        pergunta = input(f"\n🧑 Você [{contador}]: ").strip()
        
        # Verifica comandos de saída.
        if pergunta.lower() in ['sair', 'quit', 'exit', 'q']:
            print("\n🤖 Robô: Até mais, piá! Não espalha as fofoca que eu te contei, viu?")
            break
        
        # Verifica comando de reset (limpar histórico da sessão).
        if pergunta.lower() == 'reset':
            conversa_atual = []
            print("🤖 Robô: Histórico zerado! Pode falar de novo, tô de ouvido limpo.")
            continue
        
        # Se o usuário não digitou nada, pede para falar algo.
        if pergunta == "":
            print("🤖 Robô: Fala alguma coisa, guria! Tô te ouvindo...")
            continue
        
        # Mostra que o robô está "processando" (feedback visual).
        print("🤖 Robô: ", end="", flush=True)
        
        # Pequena pausa para simular pensamento (mais natural).
        time.sleep(0.5)
        
        # Gera a resposta usando IA (ou fallback offline).
        resposta = responder_com_ia(pergunta, modelo, conversa_atual)
        
        # Exibe a resposta do robô.
        print(resposta)
        
        # Cria um dicionário com a interação atual.
        interacao = {
            "pergunta": pergunta,
            "resposta": resposta,
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        
        # Adiciona ao histórico da sessão.
        conversa_atual.append(interacao)
        
        # Salva o histórico em disco a cada 3 interações (evita perda de dados).
        if contador % 3 == 0:
            salvar_conversa(conversa_atual)
    
    # Salva o histórico novamente ao final da sessão.
    if conversa_atual:
        salvar_conversa(conversa_atual)

# ============================================================
# BLOCO 11: MODO TESTE RÁPIDO (SEM INTERAÇÃO CONTÍNUA)
# ============================================================

def modo_teste_rapido():
    """
    Modo de teste com perguntas pré-definidas para verificar funcionamento.
    Útil para demonstrar o robô rapidamente sem interação manual.
    """
    
    print("\n" + "="*60)
    print("🧪 MODO TESTE RÁPIDO - Verificando o robô")
    print("="*60)
    
    # Configura a IA (ou modo offline).
    modelo = configurar_gemini()
    
    # Lista de perguntas de teste que cobrem diferentes aspectos.
    perguntas_teste = [
        "Qual é o seu nome?",
        "O que você sabe sobre acessibilidade digital?",
        "Me conta uma fofoca da escola",
        "Como eu posso deixar meu site mais acessível?",
        "Você gosta de memes?"
    ]
    
    print("\n🎭 Testando com perguntas pré-definidas:\n")
    
    # Itera sobre cada pergunta de teste.
    for i, pergunta in enumerate(perguntas_teste, 1):
        print(f"📝 Teste {i}: {pergunta}")
        print("🤖 Robô: ", end="", flush=True)
        
        # Gera resposta (sem histórico).
        resposta = responder_com_ia(pergunta, modelo, [])
        
        print(resposta)
        print("-"*50)
        
        # Aguarda 1 segundo entre perguntas para não sobrecarregar a API.
        time.sleep(1)
    
    print("\n✅ Teste concluído! O robô está pronto para conversar.")

# ============================================================
# BLOCO 12: VER HISTÓRICO DE CONVERSAS
# ============================================================

def ver_historico():
    """
    Exibe o histórico de conversas salvas.
    Mostra apenas as últimas 10 interações para não poluir a tela.
    """
    
    print("\n" + "="*60)
    print("📜 HISTÓRICO DE CONVERSAS DO ROBÔ FOFOQUEIRO")
    print("="*60)
    
    # Carrega o histórico do arquivo.
    historico = carregar_historico()
    
    # Se não há histórico, exibe mensagem informativa.
    if not historico:
        print("📭 Nenhuma conversa salva ainda! Use o modo conversa primeiro.")
        return
    
    print(f"Total de interações: {len(historico)}\n")
    
    # Pega as últimas 10 interações (ou todas se houver menos de 10).
    ultimas = historico[-10:] if len(historico) > 10 else historico
    
    # Exibe cada interação resumidamente.
    for i, interacao in enumerate(ultimas, 1):
        print(f"📌 Interação {i} ({interacao.get('timestamp', 'sem data')})")
        
        # Mostra os primeiros 80 caracteres da pergunta e resposta.
        print(f" 🧑: {interacao['pergunta'][:80]}...")
        print(f" 🤖: {interacao['resposta'][:80]}...")
        print()

# ============================================================
# BLOCO 13: CHECKLIST E MENU PRINCIPAL
# ============================================================

def checklist_ia():
    """
    Verifica se as funcionalidades da IA estão disponíveis.
    Exibe status da biblioteca e da chave da API.
    """
    
    print("\n📋 CHECKLIST DO MODO IA:")
    print("="*40)
    
    # Verifica se a biblioteca google.generativeai está instalada.
    try:
        import google.generativeai
        print("✅ Google Generative AI instalado")
    except:
        print("❌ Google Generative AI faltando")
    
    # Verifica se há uma chave de API configurada.
    chave = os.environ.get("GEMINI_API_KEY", "")
    if chave:
        print("✅ Chave da API Gemini configurada")
    else:
        print("⚠️ Nenhuma chave da API encontrada (modo offline funcionará)")
    
    print("="*40)
    print("👉 Para conversar, execute: modo_conversa()")
    print("👉 Para testar rápido, execute: modo_teste_rapido()")

def main():
    """
    Função principal com menu de opções.
    Permite ao usuário escolher entre conversar, testar, ver histórico, etc.
    """
    
    print("\n🤖 ROBÔ FOFOQUEIRO - AULA 5: IA GENERATIVA")
    print("="*50)
    print("1 - Conversar com o robô (modo chat contínuo)")
    print("2 - Teste rápido (perguntas pré-definidas)")
    print("3 - Ver histórico de conversas")
    print("4 - Verificar checklist da IA")
    print("5 - Sair")
    print("="*50)
    
    # Solicita a opção do usuário e remove espaços extras.
    opcao = input("\n👉 Escolha uma opção (1/2/3/4/5): ").strip()
    
    # Executa a opção escolhida.
    if opcao == '1':
        modo_conversa()
    elif opcao == '2':
        modo_teste_rapido()
    elif opcao == '3':
        ver_historico()
    elif opcao == '4':
        checklist_ia()
    else:
        # Opção 5 ou qualquer outra entrada: encerra o programa.
        print("\n👋 Até a próxima, piá! Não esquece de espalhar acessibilidade por aí!")
        print(" (e se ouvir uma fofoca, já sabe... conta pro robô!)")

# ============================================================
# BLOCO 14: MENSAGEM DE DEBATE ÉTICO
# ============================================================

def mensagem_debate_etico():
    """
    Exibe uma mensagem para debate ético em sala de aula.
    Estimula discussões sobre IA, privacidade, responsabilidade e inclusão.
    """
    
    print("\n" + "="*60)
    print("🧠 PARA DEBATE EM SALA DE AULA:")
    print("="*60)
    print("1. O robô realmente 'pensa' ou só combina palavras que já viu?")
    print("2. Quem é responsável pelo que o robô responde? O programador? A IA?")
    print("3. Se o robô guarda o histórico, isso é invasão de privacidade?")
    print("4. Uma IA pode ter 'personalidade' ou é só uma simulação?")
    print("5. Como garantir que IAs sejam usadas para inclusão e não para exclusão?")
    print("="*60)
    print("💬 Discutam em grupos e anotem as conclusões no diário de bordo!")

# ============================================================
# PONTO DE ENTRADA
# ============================================================

# Verifica se o script está sendo executado diretamente (não importado como módulo).
if __name__ == "__main__":
    # Chama a função principal.
    main()
    # Exibe mensagem de debate ético após o programa.
    mensagem_debate_etico()

# Mensagem final de encerramento da aula.
print("\n🎉 Fim da Aula 5 - Robô Fofoqueiro agora tem personalidade!")
print(" (Ele jura que não vai usar as fofocas contra você... ou vai?)")