📊 Mapa do Inferno Acústico

# ===================================================================
#              Robô Fofoqueiro - Mapa do Inferno Acústico
# ===================================================================
# Objetivo: Visualizar dados de medição sonora da escola,
#           criando gráficos de linha (evolução temporal),
#           mapas de calor (heatmaps) por localização e
#           gráficos de barras por período do dia.
# 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 arquivos e verificar existência de arquivos.
import os

# Importa pandas para manipulação de dados estruturados (DataFrames).
import pandas as pd

# Importa numpy para operações matemáticas e criação de arrays.
import numpy as np

# Importa matplotlib.pyplot para criação de gráficos e visualizações.
import matplotlib.pyplot as plt

# Importa seaborn para visualizações estatísticas avançadas (heatmaps, etc.).
import seaborn as sns

# Importa datetime para gerar timestamps e manipular datas/horas.
from datetime import datetime

# Importa random para gerar dados aleatórios na simulação.
import random

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:
        print("✅ Tamo no Colab! Vamos instalar as paradas com !pip.")
        return "colab"
    else:
        print("✅ Ambiente local detectado!")
        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 visualização...")

# Se o ambiente for o Google Colab, instala as bibliotecas necessárias.
if AMBIENTE == "colab":
    # Instala pandas, matplotlib, seaborn e numpy silenciosamente (-q).
    !pip install pandas matplotlib seaborn numpy -q
    print("✅ Bibliotecas instaladas (pandas, matplotlib, seaborn).")
else:
    # Se for ambiente local, apenas avisa o que precisa ser instalado.
    print("⚠️ Ambiente local: Certifique-se de ter instalado:")
    print(" pip install pandas matplotlib seaborn numpy")

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

# Reimporta as bibliotecas (garantia de que estão disponíveis).
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime

# Define o estilo padrão do matplotlib como 'ggplot' (inspirado no R).
plt.style.use('ggplot')

# Configura o seaborn com fundo branco e grade suave.
sns.set_style("whitegrid")

print("\n🎉 Bibliotecas importadas! Bora virar cientista de dados, mermão!")

# ============================================================
# BLOCO 4: ARTE ASCII DO ROBÔ (CIENTISTA DE DADOS)
# ============================================================

# String com arte ASCII representando o robô no modo cientista de dados.
# Inclui símbolos de gráficos (📊📈📉).
ascii_robo_dados = r"""
╔═══════════════════════════════════════════════════════════════╗
║ 📊📈📉                                                       ║
║ 🤖 ROBÔ FOFOQUEIRO - MODO CIENTISTA DE DADOS 🤖              ║
║ "Dado não é fofoca, é evidência, piá!"                       ║
║ "Vamos mapear o inferno acústico da escola!"                 ║
╚═══════════════════════════════════════════════════════════════╝
"""

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

# ============================================================
# BLOCO 5: CRIAR DADOS SIMULADOS (SE NÃO EXISTIR CSV)
# ============================================================

def criar_dados_simulados(arquivo="log_fofoqueiro.csv"):
    """
    Cria um arquivo CSV simulado com medições de som se ele não existir.
    Simula medições ao longo do dia (7h às 19h) em diferentes locais da escola.
    
    Parâmetros:
    arquivo: str - nome do arquivo CSV (padrão: log_fofoqueiro.csv).
    
    Retorna:
    DataFrame: pandas DataFrame com os dados carregados ou criados.
    """
    
    # Se o arquivo já existe, carrega e retorna seus dados.
    if os.path.exists(arquivo):
        print(f"📁 Arquivo {arquivo} já existe! Vamos usá-lo.")
        return pd.read_csv(arquivo)
    
    # Se não existe, cria dados simulados.
    print(f"📁 Arquivo {arquivo} não encontrado. Criando dados simulados...")
    
    # Lista para armazenar os horários (das 7h às 19h, a cada 15 minutos).
    horarios = []
    for hora in range(7, 19):          # Das 7h até 18h.
        for minuto in [0, 15, 30, 45]: # A cada 15 minutos.
            horarios.append(f"{hora:02d}:{minuto:02d}:00")
    
    # Lista de locais simulados da escola.
    locais = [
        "Sala 1 (Matemática)", "Sala 2 (Português)", "Sala 3 (Ciências)",
        "Sala 4 (História)", "Biblioteca", "Pátio/Cantina", "Laboratório",
        "Sala de Informática", "Secretaria", "Ginásio"
    ]
    
    # Lista para armazenar os dicionários de dados.
    dados = []
    
    # Itera sobre cada horário (com índice para referência, embora não usado).
    for i, horario in enumerate(horarios):
        # Extrai a hora do horário (primeiros dois caracteres).
        hora = int(horario[:2])
        
        # Define o nível de barulho base de acordo com o horário.
        if hora == 12 or hora == 17:
            # Horário de intervalo/saída: muito barulhento.
            base_barulho = 85 + random.randint(-10, 10)
        elif 9 <= hora <= 11:
            # Meio da manhã: atividade intensa.
            base_barulho = 70 + random.randint(-15, 15)
        elif 13 <= hora <= 16:
            # Tarde: atividade moderada.
            base_barulho = 55 + random.randint(-15, 15)
        else:
            # Início da manhã ou final da tarde: mais calmo.
            base_barulho = 45 + random.randint(-10, 15)
        
        # Aplica um ruído aleatório e garante que o valor fique entre 20 e 120 dB.
        decibeis = max(20, min(120, base_barulho + random.randint(-10, 10)))
        
        # Escolhe um local aleatório da lista.
        local = random.choice(locais)
        
        # Define a mensagem com base no nível de decibéis.
        if decibeis > 75:
            mensagem = "🚨 INFERNO ACÚSTICO!"
        elif decibeis > 50:
            mensagem = "⚠️ TÁ FICANDO ALTO"
        else:
            mensagem = "🤫 silêncio..."
        
        # Adiciona um dicionário com todos os dados da medição.
        dados.append({
            "Timestamp": f"2026-04-17 {horario}",  # Data fixa para simulação.
            "Decibeis (dB)": decibeis,
            "Mensagem": mensagem,
            "Local": local,
            "Hora": hora
        })
    
    # Converte a lista de dicionários em um DataFrame do pandas.
    df = pd.DataFrame(dados)
    
    # Salva o DataFrame em um arquivo CSV (sem índice, com encoding UTF-8).
    df.to_csv(arquivo, index=False, encoding='utf-8')
    
    print(f"✅ Dados simulados criados! Total de {len(df)} medições.")
    return df

# ============================================================
# BLOCO 6: GRÁFICO DE LINHA DO BARULHO AO LONGO DO DIA
# ============================================================

def grafico_linha_barulho(df):
    """
    Gera gráfico de linha mostrando a evolução do barulho ao longo do dia.
    Inclui zonas coloridas: verde (tranquilo), amarelo (atenção), vermelho (alerta).
    
    Parâmetros:
    df: DataFrame - dados com colunas 'Timestamp' e 'Decibeis (dB)'.
    
    Retorna:
    Figure - objeto da figura matplotlib.
    """
    
    print("\n" + "="*60)
    print("📈 GRÁFICO 1: Evolução do Barulho ao Longo do Dia")
    print("="*60)
    
    # Converte a coluna 'Timestamp' para datetime (formato de data/hora).
    df['Datetime'] = pd.to_datetime(df['Timestamp'])
    
    # Ordena o DataFrame por data/hora para garantir a sequência correta.
    df = df.sort_values('Datetime')
    
    # Cria uma figura com tamanho 14x7 polegadas.
    fig, ax = plt.subplots(figsize=(14, 7))
    
    # Adiciona zonas coloridas de fundo (silêncio, atenção, alerta).
    # axhspan = horizontal span (faixa horizontal).
    ax.axhspan(0, 40, alpha=0.2, color='green', label='Silêncio (0-40 dB)')
    ax.axhspan(40, 75, alpha=0.2, color='yellow', label='Atenção (40-75 dB)')
    ax.axhspan(75, 120, alpha=0.2, color='red', label='Alerta (>75 dB)')
    
    # Plota a linha principal (evolução do barulho).
    # marker='o' adiciona pontos em cada medição.
    ax.plot(df['Datetime'], df['Decibeis (dB)'],
            color='blue', linewidth=2, marker='o', markersize=4, label='Nível sonoro')
    
    # Adiciona uma linha horizontal pontilhada no limite de alerta (75 dB).
    ax.axhline(y=75, color='red', linestyle='--', linewidth=2,
               label='Limite de Alerta (75 dB)')
    
    # Configura os rótulos dos eixos.
    ax.set_xlabel('Horário', fontsize=12)
    ax.set_ylabel('Decibéis (dB)', fontsize=12)
    
    # Configura o título do gráfico.
    ax.set_title('📊 Mapa do Inferno Acústico - Barulho na Escola',
                 fontsize=14, fontweight='bold')
    
    # Adiciona legenda no canto superior direito.
    ax.legend(loc='upper right')
    
    # Adiciona grade suave (alpha=0.3 = 30% opaco).
    ax.grid(True, alpha=0.3)
    
    # Rotaciona os rótulos do eixo X em 45 graus para melhor legibilidade.
    plt.xticks(rotation=45, ha='right')
    
    # Ajusta o layout automaticamente para evitar cortes.
    plt.tight_layout()
    
    # Salva o gráfico como arquivo PNG (150 dpi de resolução).
    plt.savefig('grafico_barulho_linha.png', dpi=150, bbox_inches='tight')
    print("💾 Gráfico salvo como 'grafico_barulho_linha.png'")
    
    # Exibe o gráfico na tela.
    plt.show()
    
    return fig

# ============================================================
# BLOCO 7: HEATMAP DO MAPA DA ESCOLA (SIMULAÇÃO)
# ============================================================

def criar_heatmap_escola(df):
    """
    Cria um heatmap (mapa de calor) simulando o mapa da escola.
    Cada "sala" (célula da matriz) recebe um nível médio de barulho,
    com valores mais altos no centro (simulando áreas de circulação).
    
    Parâmetros:
    df: DataFrame - dados (usado apenas para referência, não essencial).
    
    Retorna:
    Figure - objeto da figura matplotlib.
    """
    
    print("\n" + "="*60)
    print("🗺️ GRÁFICO 2: Mapa de Calor do Barulho por Sala")
    print("="*60)
    
    # Define o tamanho da matriz (5x5 = 25 "salas").
    tamanho = 5
    
    # Gera uma matriz inicial com valores aleatórios entre 30 e 100 dB.
    matriz_barulho = np.random.randint(30, 100, size=(tamanho, tamanho))
    
    # Aplica um efeito de "centro barulhento" (simula áreas comuns).
    # Quanto mais próximo do centro, mais barulho é adicionado.
    for i in range(tamanho):
        for j in range(tamanho):
            # Calcula a distância Manhattan do centro da matriz.
            distancia_centro = abs(i - tamanho//2) + abs(j - tamanho//2)
            # Adiciona mais barulho quanto menor a distância do centro.
            # Limita o valor máximo a 100 dB.
            matriz_barulho[i, j] = min(100, matriz_barulho[i, j] + (5 - distancia_centro) * 5)
    
    # Cria uma figura com tamanho 10x8 polegadas.
    fig, ax = plt.subplots(figsize=(10, 8))
    
    # Cria o heatmap usando seaborn.
    # annot=True: mostra os valores numéricos nas células.
    # fmt='.0f': formata os valores sem casas decimais.
    # cmap='RdYlGn_r': esquema de cores (vermelho-amarelo-verde invertido).
    # center=75: centraliza o mapa de cores em 75 dB (limite de alerta).
    # vmin=30, vmax=100: limites mínimo e máximo da escala.
    sns.heatmap(matriz_barulho, annot=True, fmt='.0f', cmap='RdYlGn_r',
                center=75, vmin=30, vmax=100,
                cbar_kws={'label': 'Decibéis (dB)'},
                ax=ax)
    
    # Configura o título do gráfico.
    ax.set_title('🗺️ Mapa de Calor do Inferno Acústico\n(Quanto mais vermelho, mais barulhento)',
                 fontsize=14, fontweight='bold')
    
    # Configura os rótulos dos eixos.
    ax.set_xlabel('Salas (Eixo X)', fontsize=12)
    ax.set_ylabel('Salas (Eixo Y)', fontsize=12)
    
    # Ajusta o layout automaticamente.
    plt.tight_layout()
    
    # Salva o heatmap como arquivo PNG.
    plt.savefig('heatmap_escola.png', dpi=150, bbox_inches='tight')
    print("💾 Heatmap salvo como 'heatmap_escola.png'")
    
    # Exibe o gráfico na tela.
    plt.show()
    
    return fig

# ============================================================
# BLOCO 8: GRÁFICO DE BARRAS (BARULHO POR PERÍODO)
# ============================================================

def grafico_barras_periodo(df):
    """
    Cria gráfico de barras mostrando a média de barulho por período do dia.
    Períodos: Manhã (7h-12h), Intervalo (12h-13h), Tarde (13h-18h).
    
    Parâmetros:
    df: DataFrame - dados com coluna 'Hora' e 'Decibeis (dB)'.
    
    Retorna:
    Figure - objeto da figura matplotlib.
    """
    
    print("\n" + "="*60)
    print("📊 GRÁFICO 3: Barulho Médio por Período do Dia")
    print("="*60)
    
    # Se a coluna 'Hora' não existir, extrai a hora do timestamp.
    if 'Hora' not in df.columns:
        df['Hora'] = pd.to_datetime(df['Timestamp']).dt.hour
    
    # Função interna para classificar o período baseado na hora.
    def classificar_periodo(hora):
        if 7 <= hora < 12:
            return "Manhã (7h-12h)"
        elif 12 <= hora < 13:
            return "Intervalo (12h-13h)"
        elif 13 <= hora < 18:
            return "Tarde (13h-18h)"
        else:
            return "Outros"
    
    # Aplica a função para criar a coluna 'Periodo'.
    df['Periodo'] = df['Hora'].apply(classificar_periodo)
    
    # Calcula a média de decibéis por período e ordena.
    media_por_periodo = df.groupby('Periodo')['Decibeis (dB)'].mean().sort_values()
    
    # Define as cores das barras com base no valor médio.
    cores = []
    for periodo in media_por_periodo.index:
        media = media_por_periodo[periodo]
        if media > 75:
            cores.append('red')      # Alerta máximo.
        elif media > 50:
            cores.append('orange')   # Atenção.
        else:
            cores.append('green')    # Silêncio.
    
    # Cria uma figura com tamanho 10x6 polegadas.
    fig, ax = plt.subplots(figsize=(10, 6))
    
    # Cria o gráfico de barras.
    barras = ax.bar(media_por_periodo.index, media_por_periodo.values,
                    color=cores, alpha=0.8, edgecolor='black')
    
    # Adiciona linha horizontal pontilhada no limite de alerta (75 dB).
    ax.axhline(y=75, color='red', linestyle='--', linewidth=2,
               label='Limite de Alerta (75 dB)')
    
    # Adiciona os valores numéricos acima de cada barra.
    for barra, valor in zip(barras, media_por_periodo.values):
        ax.text(barra.get_x() + barra.get_width()/2, barra.get_height() + 2,
                f'{valor:.0f} dB', ha='center', va='bottom', fontsize=10)
    
    # Configura os rótulos dos eixos.
    ax.set_xlabel('Período', fontsize=12)
    ax.set_ylabel('Decibéis Médios (dB)', fontsize=12)
    
    # Configura o título do gráfico.
    ax.set_title('🔊 Barulho Médio por Período - Qual horário é mais barulhento?',
                 fontsize=14, fontweight='bold')
    
    # Adiciona legenda.
    ax.legend()
    
    # Adiciona grade apenas no eixo Y.
    ax.grid(True, alpha=0.3, axis='y')
    
    # Ajusta a rotação dos rótulos do eixo X (sem rotação).
    plt.xticks(rotation=0)
    
    # Ajusta o layout automaticamente.
    plt.tight_layout()
    
    # Salva o gráfico como arquivo PNG.
    plt.savefig('grafico_barras_periodo.png', dpi=150, bbox_inches='tight')
    print("💾 Gráfico de barras salvo como 'grafico_barras_periodo.png'")
    
    # Exibe o gráfico na tela.
    plt.show()
    
    return fig

# ============================================================
# BLOCO 9: ESTATÍSTICAS E ANÁLISE DOS DADOS
# ============================================================

def analise_estatistica(df):
    """
    Calcula e exibe estatísticas descritivas dos dados.
    Inclui médias, medianas, desvio padrão, valores extremos,
    distribuição por níveis de alerta e identificação de horários/locais críticos.
    
    Parâmetros:
    df: DataFrame - dados a serem analisados.
    """
    
    print("\n" + "="*60)
    print("📐 ANÁLISE ESTATÍSTICA - O Inferno Acústico em Números")
    print("="*60)
    
    print("\n📊 ESTATÍSTICAS GERAIS:")
    print("-" * 40)
    print(f"Total de medições: {len(df)}")
    print(f"Média de decibéis: {df['Decibeis (dB)'].mean():.1f} dB")
    print(f"Mediana: {df['Decibeis (dB)'].median():.1f} dB")
    print(f"Desvio padrão: {df['Decibeis (dB)'].std():.1f} dB")
    print(f"Máximo registrado: {df['Decibeis (dB)'].max():.1f} dB")
    print(f"Mínimo registrado: {df['Decibeis (dB)'].min():.1f} dB")
    
    # Calcula contagens por nível de alerta.
    alertas = len(df[df['Decibeis (dB)'] > 75])
    atencao = len(df[(df['Decibeis (dB)'] > 50) & (df['Decibeis (dB)'] <= 75)])
    silencio = len(df[df['Decibeis (dB)'] <= 50])
    
    print("\n🚨 NÍVEIS DE ALERTA:")
    print("-" * 40)
    print(f"🔴 INFERNO ACÚSTICO (>75 dB): {alertas} medições ({alertas/len(df)*100:.1f}%)")
    print(f"🟡 ATENÇÃO (50-75 dB): {atencao} medições ({atencao/len(df)*100:.1f}%)")
    print(f"🟢 SILÊNCIO (≤50 dB): {silencio} medições ({silencio/len(df)*100:.1f}%)")
    
    # Se a coluna 'Hora' existir, identifica o horário mais barulhento e mais calmo.
    if 'Hora' in df.columns:
        # Agrupa por hora e calcula a média de decibéis.
        media_por_hora = df.groupby('Hora')['Decibeis (dB)'].mean()
        
        # Hora com maior média.
        hora_mais_barulhenta = media_por_hora.idxmax()
        
        # Hora com menor média.
        hora_mais_calma = media_por_hora.idxmin()
        
        print(f"\n⏰ HORA MAIS BARULHENTA: {hora_mais_barulhenta}h")
        print(f"😴 HORA MAIS CALMA: {hora_mais_calma}h")
    
    # Se a coluna 'Local' existir, identifica o local mais barulhento e mais calmo.
    if 'Local' in df.columns:
        # Agrupa por local e calcula a média de decibéis.
        media_por_local = df.groupby('Local')['Decibeis (dB)'].mean()
        
        # Local com maior média.
        local_mais_barulhento = media_por_local.idxmax()
        
        # Local com menor média.
        local_mais_calmo = media_por_local.idxmin()
        
        print(f"\n📍 LOCAL MAIS BARULHENTO: {local_mais_barulhento}")
        print(f"🤫 LOCAL MAIS CALMO: {local_mais_calmo}")

# ============================================================
# BLOCO 10: EXPORTAR RELATÓRIO COMPLETO
# ============================================================

def exportar_relatorio(df):
    """
    Exporta um relatório completo em formato texto (.txt).
    Inclui estatísticas, recomendações baseadas nos dados e metadados.
    
    Parâmetros:
    df: DataFrame - dados a serem relatados.
    """
    
    print("\n" + "="*60)
    print("📄 GERANDO RELATÓRIO COMPLETO")
    print("="*60)
    
    # Lista para acumular as linhas do relatório.
    relatorio = []
    
    # Cabeçalho do relatório.
    relatorio.append("="*60)
    relatorio.append("RELATÓRIO DO ROBÔ FOFOQUEIRO - MAPA DO INFERNO ACÚSTICO")
    relatorio.append(f"Data de geração: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    relatorio.append("="*60)
    relatorio.append("")
    
    # Seção de estatísticas gerais.
    relatorio.append("📊 ESTATÍSTICAS GERAIS:")
    relatorio.append(f"Total de medições: {len(df)}")
    relatorio.append(f"Média de decibéis: {df['Decibeis (dB)'].mean():.1f} dB")
    relatorio.append(f"Mediana: {df['Decibeis (dB)'].median():.1f} dB")
    relatorio.append(f"Máximo: {df['Decibeis (dB)'].max():.1f} dB")
    relatorio.append(f"Mínimo: {df['Decibeis (dB)'].min():.1f} dB")
    relatorio.append("")
    
    # Seção de alertas.
    alertas = len(df[df['Decibeis (dB)'] > 75])
    relatorio.append(f"🔴 Alertas (>75 dB): {alertas} medições ({alertas/len(df)*100:.1f}%)")
    relatorio.append("")
    
    # Seção de recomendações baseadas no percentual de alertas.
    relatorio.append("📋 RECOMENDAÇÕES:")
    if alertas/len(df) > 0.3:
        # Mais de 30% das medições acima do limite: situação crítica.
        relatorio.append("⚠️ ALERTA CRÍTICO: Mais de 30% das medições estão acima do limite!")
        relatorio.append(" → Sugerimos campanha de conscientização sobre poluição sonora")
        relatorio.append(" → Instalar painéis acústicos nas áreas mais críticas")
    elif alertas/len(df) > 0.1:
        # Entre 10% e 30% das medições acima do limite: atenção.
        relatorio.append("⚠️ ATENÇÃO: Entre 10% e 30% das medições estão acima do limite")
        relatorio.append(" → Identificar horários e locais mais problemáticos")
    else:
        # Menos de 10% das medições acima do limite: ambiente controlado.
        relatorio.append("✅ AMBIENTE CONTROLADO: Menos de 10% das medições acima do limite")
        relatorio.append(" → Manter as boas práticas atuais")
    
    # Salva o relatório em um arquivo de texto.
    with open("relatorio_inferno_acustico.txt", "w", encoding="utf-8") as f:
        f.write("\n".join(relatorio))
    
    print("💾 Relatório salvo como 'relatorio_inferno_acustico.txt'")
    
    # Exibe o relatório na tela.
    print("\n".join(relatorio))

# ============================================================
# BLOCO 11: FUNÇÃO PRINCIPAL
# ============================================================

def main():
    """
    Função principal que orquestra toda a análise.
    Exibe um menu para o usuário escolher quais visualizações gerar.
    """
    
    print("\n🤖 ROBÔ FOFOQUEIRO - AULA 7: MAPA DO INFERNO ACÚSTICO")
    print("="*50)
    
    # Carrega ou cria os dados.
    df = criar_dados_simulados("log_fofoqueiro.csv")
    
    # Exibe informações básicas sobre os dados carregados.
    print(f"\n📊 Dados carregados: {len(df)} medições")
    print(f"📅 Período: {df['Timestamp'].min()} até {df['Timestamp'].max()}")
    
    # Menu de opções.
    print("\n" + "="*50)
    print("📌 O QUE VOCÊ QUER VISUALIZAR?")
    print("="*50)
    print("1 - Gráfico de linha (evolução do barulho ao longo do dia)")
    print("2 - Mapa de calor (heatmap) das salas")
    print("3 - Gráfico de barras (barulho por período)")
    print("4 - Análise estatística completa")
    print("5 - Exportar relatório")
    print("6 - TUDO DE UMA VEZ (recomendado)")
    print("7 - Sair")
    print("="*50)
    
    # Solicita a opção do usuário.
    opcao = input("\n👉 Escolha uma opção (1/2/3/4/5/6/7): ").strip()
    
    # Executa a opção escolhida.
    if opcao == '1':
        grafico_linha_barulho(df)
    elif opcao == '2':
        criar_heatmap_escola(df)
    elif opcao == '3':
        grafico_barras_periodo(df)
    elif opcao == '4':
        analise_estatistica(df)
    elif opcao == '5':
        exportar_relatorio(df)
    elif opcao == '6':
        # Executa todas as análises em sequência.
        grafico_linha_barulho(df)
        criar_heatmap_escola(df)
        grafico_barras_periodo(df)
        analise_estatistica(df)
        exportar_relatorio(df)
    else:
        # Opção 7 ou qualquer outra: encerra o programa.
        print("\n👋 Até a próxima, cientista de dados! Não esquece: fofoca com evidência é pesquisa!")

def mensagem_debate_dados():
    """
    Exibe uma mensagem para debate sobre análise de dados e acessibilidade.
    Estimula discussões sobre como os dados podem ser usados para
    melhorar o ambiente escolar e torná-lo mais inclusivo.
    """
    
    print("\n" + "="*60)
    print("🧠 PARA DEBATE EM SALA DE AULA:")
    print("="*60)
    print("1. Quais horários são mais barulhentos na sua escola? Por quê?")
    print("2. Como o mapa de calor pode ajudar a planejar ações para reduzir o barulho?")
    print("3. Que outras variáveis poderiam ser medidas além do barulho?")
    print("4. Como os dados podem ser usados para tornar a escola mais acessível?")
    print("5. Qual a importância de visualizar dados para a tomada de decisã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__":
    main()                       # Chama a função principal.
    mensagem_debate_dados()      # Exibe mensagem de debate.

# Mensagem final de encerramento da aula.
print("\n🎉 Fim da Aula 7 - Robô Fofoqueiro agora é cientista de dados!")
print(" (Ele descobriu que o intervalo é o horário mais barulhento... surpresa, né?)")