🎤 Reconhecimento de Fala

# ===================================================================
#              Robô Fofoqueiro - Reconhecimento de Fala
# ===================================================================
# Objetivo: Capturar áudio do microfone, converter fala em texto usando
#           a API do Google Speech Recognition, salvar as "fofocas" em
#           arquivo de log, responder com mensagens irreverentes e
#           oferecer tradução textual para Libras (usando emojis).
# Alunos: [A SER PREENCHIDO]
# Orientadora: Gisele Nunes
# Data  : 2026
# ===================================================================

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

# Importa a biblioteca SpeechRecognition para capturar áudio do microfone
# e converter fala em texto através da API do Google.
import speech_recognition as sr

# Importa datetime para gerar timestamps precisos quando salvar as fofocas.
from datetime import datetime

# Importa random para escolher respostas aleatórias da lista de frases irreverentes.
import random

# Importa os para manipular arquivos e caminhos do sistema.
import os

# Importa time para adicionar pausas (sleep) entre os testes simulados.
import time

# ============================================================
# LISTA DE RESPOSTAS IRREVERENTES
# ============================================================

# Lista de strings contendo respostas engraçadas e descontraídas que o robô
# pode dar após ouvir uma fala. O marcador '{}' será substituído pelo texto
# que o usuário falou.
RESPOSTAS_IRREVERENTES = [
    "Ah pronto, agora tão falando '{}'... vou contar pra todo mundo",
    "Isso foi profundo... ou não, sei lá, sou só um robô fofoqueiro",
    "Anotado! '{}' - disse o aluno misterioso",
    "Huuum, interessante... vou salvar no meu banco de fofocas",
    "😈 Hehehe... '{}'... isso vai render altas fofocas!",
    "Conta mais, conta mais... tô gravando tudo aqui 🎙️",
    "Vixi, falou '{}'! Égua, isso é bagulho doido!",
    "Piá, cê tá ligado que eu anotei isso né? '{}'",
    "Ó o trem, guria! '{}' - anotado com sucesso!"
]

# ============================================================
# DICIONÁRIO DE GÍRIAS PARANAENSES
# ============================================================

# Dicionário que mapeia gírias típicas do Paraná para seus significados
# com emojis ilustrativos. Usado para detectar gírias na fala do usuário
# e responder de forma personalizada.
DICIONARIO_GIRIAS = {
    "vixi": "😲 expressão de surpresa ou susto",
    "piá": "🧒 garoto, rapaz",
    "guria": "👧 garota, moça",
    "ó o trem": "👀 olha a coisa, presta atenção",
    "tchê": "🤝 companheiro, amigo",
    "bagulho doido": "🤪 coisa louca, situação complicada",
    "égua": "🐴 expressão de espanto",
    "trem": "📦 coisa, objeto",
    "bah": "😮 expressão de surpresa",
    "mas qué isso": "😯 expressão de indignação"
}

# ============================================================
# DICIONÁRIO DE TRADUÇÃO PARA LIBRAS TEXTUAL (EMOJI)
# ============================================================

# Dicionário que traduz palavras ou frases comuns para uma representação
# textual com emojis, simulando sinais de Libras de forma lúdica e acessível.
# A chave é a palavra/frase em português, o valor é a "tradução" com emojis.
LIBRAS_EMOJI = {
    "bom dia": "🤟 BOM DIA 🤟",
    "boa tarde": "🌅 BOA TARDE 🌅",
    "boa noite": "🌙 BOA NOITE 🌙",
    "ajuda": "🆘 AJUDA 🆘",
    "obrigado": "🙏 OBRIGADO 🙏",
    "amigo": "🤝 AMIGO 🤝",
    "escola": "📚 ESCOLA 📚",
    "professor": "👨‍🏫 PROFESSOR 👨‍🏫",
    "fofoca": "👂 FOFOCA 👂",
    "segredo": "🤫 SEGREDO 🤫",
    "amor": "❤️ AMOR ❤️",
    "triste": "😢 TRISTE 😢",
    "feliz": "😊 FELIZ 😊",
    "legal": "👍 LEGAL 👍",
    "ruim": "👎 RUIM 👎",
    "programar": "💻 PROGRAMAR 💻",
    "python": "🐍 PYTHON 🐍",
    "robô": "🤖 ROBÔ 🤖"
}

# ============================================================
# FUNÇÃO PARA SALVAR FOFOCO NO ARQUIVO
# ============================================================

def salvar_fofoca(texto):
    """
    Salva uma fofoca (texto capturado) em um arquivo chamado 'fofocas.txt'.
    Cada linha contém um timestamp e o texto dito pelo usuário.
    
    Parâmetros:
    texto: str - o texto que foi reconhecido (ou simulado).
    """
    
    # Gera um timestamp com data e hora no formato ANO-MÊS-DIA HORA:MINUTO:SEGUNDO.
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    # Abre o arquivo 'fofocas.txt' em modo de adição ('a' = append).
    # Se o arquivo não existir, será criado automaticamente.
    # encoding='utf-8' garante suporte a caracteres especiais (emojis, acentos).
    with open("fofocas.txt", "a", encoding="utf-8") as arquivo:
        # Escreve uma linha com o timestamp e o texto entre colchetes.
        arquivo.write(f"[{timestamp}] - {texto}\n")
    
    # Exibe mensagem de confirmação para o usuário.
    print(f"💾 Fofoca salva com sucesso!")

# ============================================================
# FUNÇÃO PARA TRADUZIR PARA LIBRAS TEXTUAL
# ============================================================

def traduzir_libras_textual(texto):
    """
    Traduz palavras/frases específicas para uma representação textual com emojis,
    simulando sinais de Libras de forma lúdica.
    
    Parâmetros:
    texto: str - o texto original reconhecido.
    
    Retorna:
    str - o texto modificado com as traduções aplicadas (se houver).
    """
    
    # Converte o texto original para letras minúsculas para facilitar a comparação.
    texto_lower = texto.lower()
    
    # Percorre cada palavra/frase do dicionário de Libras.
    for palavra, traducao in LIBRAS_EMOJI.items():
        # Se a palavra (em minúsculo) estiver presente no texto.
        if palavra in texto_lower:
            # Substitui a palavra original pela tradução com emojis.
            # Usa o texto original (com maiúsculas preservadas) para substituição.
            return texto.replace(palavra, traducao)
    
    # Se nenhuma palavra do dicionário for encontrada, retorna o texto original.
    return texto

# ============================================================
# FUNÇÃO PARA GERAR RESPOSTA COM GÍRIAS
# ============================================================

def gerar_resposta_com_girias(texto):
    """
    Detecta se o texto contém alguma gíria paranaense e gera uma resposta
    personalizada. Caso contrário, escolhe uma resposta irreverente aleatória.
    
    Parâmetros:
    texto: str - o texto reconhecido.
    
    Retorna:
    str - a resposta do robô fofoqueiro.
    """
    
    # Converte o texto para minúsculas para comparação case-insensitive.
    texto_lower = texto.lower()
    
    # Percorre todas as gírias do dicionário.
    for giria, significado in DICIONARIO_GIRIAS.items():
        # Se a gíria estiver presente no texto.
        if giria in texto_lower:
            # Retorna uma resposta específica explicando o significado da gíria.
            return f"Vixi, você usou '{giria}'! {significado} Égua, sabia nem que existia isso! 🤯"
    
    # Se nenhuma gíria for detectada, escolhe uma resposta aleatória da lista
    # e formata com o texto original do usuário.
    return random.choice(RESPOSTAS_IRREVERENTES).format(texto)

# ============================================================
# FUNÇÃO PRINCIPAL DE RECONHECIMENTO DE FALA
# ============================================================

def escuta_fofoqueiro(modo_libras=False):
    """
    Função principal que captura áudio do microfone, converte para texto
    usando a API do Google, salva a fofoca e gera uma resposta.
    
    Parâmetros:
    modo_libras: bool - se True, ativa a tradução textual para Libras.
    
    Retorna:
    str or None - o texto reconhecido, ou None se houve erro.
    """
    
    # Mensagem inicial informando que o robô está ouvindo.
    print("\n🎤 Robô Fofoqueiro: 'Tô te ouvindo... fala aí que eu tô anotando tudo'")
    
    # Cria uma instância do reconhecedor de fala.
    recognizer = sr.Recognizer()
    
    # Define o limiar de energia (sensibilidade) para detectar fala.
    # Valores mais baixos detectam sons mais baixos.
    recognizer.energy_threshold = 300
    
    # Define a pausa mínima (em segundos) para considerar que a fala terminou.
    recognizer.pause_threshold = 0.8
    
    try:
        # Abre o microfone como fonte de áudio.
        with sr.Microphone() as source:
            print("🔴 Gravando... fale alguma coisa!")
            
            # Ajusta o reconhecedor para o ruído ambiente por 0.5 segundo.
            recognizer.adjust_for_ambient_noise(source, duration=0.5)
            
            # Escuta o áudio do microfone.
            # timeout=5: espera no máximo 5 segundos pelo início da fala.
            # phrase_time_limit=5: limita a duração da frase a 5 segundos.
            audio = recognizer.listen(source, timeout=5, phrase_time_limit=5)
            
            print("✅ Áudio capturado! Processando...")
            
            try:
                # Tenta reconhecer o áudio usando a API do Google em português do Brasil.
                texto = recognizer.recognize_google(audio, language="pt-BR")
                print(f"👂 OUVI ALGO: {texto}")
            
            except sr.UnknownValueError:
                # O Google não conseguiu entender o áudio (ex: muito ruído, fala ininteligível).
                print("❌ Google não entendeu o áudio!")
                return None
            
            except sr.RequestError as e:
                # Erro de conexão ou problema na requisição à API do Google.
                print(f"❌ Erro na requisição ao Google: {e}")
                return None
    
    except sr.WaitTimeoutError:
        # O usuário não começou a falar dentro do tempo limite (timeout).
        print("⏰ Tempo esgotado! Você demorou para começar a falar.")
        return None
    
    except Exception as e:
        # Captura qualquer outro erro inesperado.
        print(f"❌ Erro inesperado: {e}")
        return None
    
    # Se o texto foi reconhecido com sucesso.
    if texto:
        # Se o modo Libras estiver ativado, traduz o texto.
        if modo_libras:
            texto_original = texto
            texto = traduzir_libras_textual(texto)
            # Só exibe a mensagem de tradução se houve alteração.
            if texto != texto_original:
                print(f"🦾 TRADUÇÃO LIBRAS: {texto}")
        
        # Salva o texto (fofoca) no arquivo.
        salvar_fofoca(texto)
        
        # Gera uma resposta irreverente (com ou sem gírias).
        resposta = gerar_resposta_com_girias(texto)
        
        # Exibe a resposta do robô.
        print(f"🤖 {resposta}")
        
        # Retorna o texto reconhecido.
        return texto
    
    # Se algo deu errado e texto está vazio/None, retorna None.
    return None

# ============================================================
# FUNÇÃO PARA TESTE SIMULADO (SEM MICROFONE)
# ============================================================

def teste_simulado(modo_libras=False):
    """
    Função para testar o robô sem necessidade de microfone.
    Usa uma lista de frases pré-definidas e simula o reconhecimento.
    Útil para executar no Google Colab onde o microfone pode não estar disponível.
    
    Parâmetros:
    modo_libras: bool - se True, ativa a tradução textual para Libras.
    """
    
    # Cabeçalho visual para o modo de teste.
    print("\n" + "="*60)
    print("🧪 MODO TESTE SIMULADO - Robô Fofoqueiro em ação!")
    print("="*60)
    
    # Lista de frases de teste que simulam possíveis falas de usuários.
    frases_teste = [
        "bom dia professor, como você está?",
        "preciso de ajuda com o exercício",
        "você ouviu a última fofoca da escola?",
        "estou feliz hoje!",
        "isso é um segredo entre nós",
        "vixi, que bagulho doido!",
        "ó o trem, piá!"
    ]
    
    print("\n🎭 Simulando reconhecimento de fala com frases pré-definidas:\n")
    
    # Percorre cada frase de teste com índice começando em 1.
    for i, frase_simulada in enumerate(frases_teste, 1):
        print(f"📝 Teste {i}/{len(frases_teste)}:")
        print(f" 🎭 Frase simulada: '{frase_simulada}'")
        
        # No teste simulado, o texto é a própria frase (não vem de microfone).
        texto = frase_simulada
        print(f"👂 OUVI ALGO: {texto}")
        
        # Se o modo Libras estiver ativado, traduz o texto.
        if modo_libras:
            texto_original = texto
            texto = traduzir_libras_textual(texto)
            if texto != texto_original:
                print(f"🦾 TRADUÇÃO LIBRAS: {texto}")
        
        # Salva a fofoca com um marcador [SIMULADO] para diferenciar de gravações reais.
        salvar_fofoca(f"[SIMULADO] {texto}")
        
        # Gera e exibe a resposta do robô.
        resposta = gerar_resposta_com_girias(texto)
        print(f"🤖 {resposta}")
        
        # Linha separadora visual.
        print("-"*40)
        
        # Aguarda 1 segundo antes do próximo teste para não sobrecarregar a saída.
        time.sleep(1)
    
    # Mensagem final de conclusão do teste.
    print("\n✅ Teste simulado concluído!")
    print("📁 Verifique o arquivo 'fofocas.txt' para ver as fofocas salvas!")

# ============================================================
# FUNÇÃO PRINCIPAL
# ============================================================

def main():
    """
    Função principal que exibe o menu de opções e orquestra a execução
    do robô fofoqueiro conforme a escolha do usuário.
    """
    
    # Cabeçalho de apresentação do programa.
    print("="*60)
    print("🤖 ROBÔ FOFOQUEIRO - AULA 3: RECONHECIMENTO DE FALA")
    print("="*60)
    
    # Menu de opções disponíveis para o usuário.
    print("\n📌 Como você quer testar o robô?")
    print("1 - Teste com microfone real (precisa de microfone)")
    print("2 - Teste simulado (usa frases pré-definidas, recomendado para Colab)")
    print("3 - Apenas ver fofocas salvas")
    
    try:
        # Solicita ao usuário que escolha uma opção e remove espaços extras.
        opcao = input("\n👉 Escolha uma opção (1/2/3): ").strip()
        
        # Pergunta se deseja ativar a tradução para Libras textual.
        modo_libras_input = input("🦾 Ativar tradução para Libras textual? (s/n): ").strip().lower()
        
        # Converte a resposta para booleano: True se for 's', False caso contrário.
        modo_libras = modo_libras_input == 's'
        
        # Opção 1: Teste com microfone real.
        if opcao == '1':
            print("\n🎙️ Iniciando teste com microfone real...")
            print("Pressione Ctrl+C para parar...")
            try:
                # Loop infinito até o usuário interromper com Ctrl+C.
                while True:
                    # Chama a função de escuta e aguarda o reconhecimento.
                    texto = escuta_fofoqueiro(modo_libras=modo_libras)
                    if texto:
                        print(f"✅ Texto salvo: {texto}")
                    print("\n" + "-"*40)
                    time.sleep(1)
            except KeyboardInterrupt:
                # Captura Ctrl+C para encerrar o programa graciosamente.
                print("\n\n👋 Robô Fofoqueiro desligado! Até a próxima fofoca!")
        
        # Opção 2: Teste simulado (recomendado para Colab).
        elif opcao == '2':
            teste_simulado(modo_libras=modo_libras)
        
        # Opção 3: Exibir fofocas já salvas.
        elif opcao == '3':
            try:
                # Tenta abrir e ler o arquivo de fofocas.
                with open("fofocas.txt", "r", encoding="utf-8") as arquivo:
                    print(arquivo.read())
            except FileNotFoundError:
                # Se o arquivo não existir, exibe mensagem informativa.
                print("📭 Nenhuma fofoca salva ainda!")
        
        # Opção inválida: executa o teste simulado como fallback.
        else:
            print("❌ Opção inválida! Executando teste simulado padrão...")
            teste_simulado(modo_libras=modo_libras)
    
    except Exception as e:
        # Captura qualquer erro no menu e executa o teste simulado como fallback.
        print(f"❌ Erro: {e}")
        teste_simulado(modo_libras=False)

# Verifica se o script está sendo executado diretamente (não importado como módulo).
if __name__ == "__main__":
    # Chama a função principal para iniciar o programa.
    main()

# Exibe mensagem final de encerramento após o término da execução.
print("\n" + "="*60)
print("👋 Robô Fofoqueiro encerrado!")
print("😈 Lembre-se: tudo que você falou está salvo em 'fofocas.txt'")
print("="*60)