# ============================================================
# ALGORITMO DE RECOMENDAÇÃO SIMPLIFICADO (VERSÃO DIDÁTICA)
# ============================================================
#
# Este código simula, de forma extremamente simplificada, como
# um algoritmo de recomendação decide o que mostrar para um usuário.
#
# NA VIDA REAL: milhões de variáveis, redes neurais, dados
# massivos e interesses bilionários.
# AQUI: só para entender a lógica por trás da "mágica".
# ============================================================

# 1. BANCO DE DADOS DO USUÁRIO (o que o algoritmo "sabe" sobre você)
# Na vida real, isso vem do seu histórico de navegação, curtidas,
# tempo de visualização, localização, dispositivo, hora do dia...

usuario = {
    "nome": "João",
    "idade": 16,
    "interesses": ["futebol", "jogos", "humor"],  # baseado no que ele curtiu
    "historico": [  # o que ele já assistiu/curtiu
        {"titulo": "Melhores gols de 2024", "categoria": "futebol", "curtiu": True},
        {"titulo": "Gameplay de Minecraft", "categoria": "jogos", "curtiu": True},
        {"titulo": "Receita de bolo de chocolate", "categoria": "culinaria", "curtiu": False},
    ]
}

# 2. BANCO DE DADOS DE CONTEÚDO (o que o algoritmo pode te mostrar)
# Na vida real: milhões de vídeos, posts, anúncios, músicas...

conteudos = [
    {"id": 1, "titulo": "Golaço de falta - Brasileirão 2025", "categoria": "futebol"},
    {"id": 2, "titulo": "Tutorial de Python para iniciantes", "categoria": "programacao"},
    {"id": 3, "titulo": "Melhores momentos - Copa do Mundo", "categoria": "futebol"},
    {"id": 4, "titulo": "Novo jogo da Rockstar - análise", "categoria": "jogos"},
    {"id": 5, "titulo": "Como fazer miojo gourmet", "categoria": "culinaria"},
    {"id": 6, "titulo": "Prank com amigos - pegadinha épica", "categoria": "humor"},
    {"id": 7, "titulo": "Documentário sobre mudanças climáticas", "categoria": "ciencia"},
]

# 3. FUNÇÃO DE RECOMENDAÇÃO (o coração do algoritmo)
# É aqui que a "mágica" acontece. Na vida real, isso é uma
# rede neural com bilhões de parâmetros. Aqui, é uma simples
# contagem de interesses em comum.

def recomendar(usuario, conteudos):
    """
    Recomenda conteúdos com base nos interesses do usuário.
    PASSO A PASSO (ALGORITMO):
    1. Para cada conteúdo disponível...
    2. ...conte quantos interesses do usuário ele atende.
    3. Ordene os conteúdos do mais relevante para o menos relevante.
    4. Retorne os 3 primeiros (top 3).
    """
    # DECOMPOSIÇÃO: vamos analisar cada conteúdo individualmente
    recomendacoes = []
    for conteudo in conteudos:
        # RECONHECIMENTO DE PADRÕES: o conteúdo tem algo a ver
        # com os interesses do usuário?
        pontuacao = 0
        # Verifica se a categoria do conteúdo está nos interesses do usuário
        if conteudo["categoria"] in usuario["interesses"]:
            pontuacao += 1  # cada interesse compatível = +1 ponto
        # Verifica se o usuário já curtiu algo similar no histórico
        for item in usuario["historico"]:
            if item["categoria"] == conteudo["categoria"] and item["curtiu"]:
                pontuacao += 0.5  # curtiu algo similar = +0.5 ponto
        recomendacoes.append({
            "conteudo": conteudo,
            "pontuacao": pontuacao
        })
    # ALGORITMO: ordenar do maior para o menor (os mais relevantes primeiro)
    recomendacoes.sort(key=lambda x: x["pontuacao"], reverse=True)
    # ABSTRAÇÃO: retornamos apenas os 3 melhores (simplificamos o resultado)
    return recomendacoes[:3]

# 4. EXECUTANDO O ALGORITMO
print("=" * 50)
print("🤖 ALGORITMO DE RECOMENDAÇÃO EM AÇÃO")
print("=" * 50)
print(f"\n👤 Usuário: {usuario['nome']}")
print(f"📌 Interesses: {', '.join(usuario['interesses'])}")
print(f"📜 Histórico: {len(usuario['historico'])} itens")
print("\n⏳ Processando...")
print("-" * 50)

resultados = recomendar(usuario, conteudos)

print("\n🎯 TOP 3 RECOMENDAÇÕES:")
for i, resultado in enumerate(resultados, 1):
    conteudo = resultado["conteudo"]
    print(f"\n{i}. {conteudo['titulo']}")
    print(f"   📂 Categoria: {conteudo['categoria']}")
    print(f"   ⭐ Relevância: {resultado['pontuacao']} pontos")

print("\n" + "=" * 50)
print("💡 REFLEXÃO:")
print("- O algoritmo te mostrou o que você QUER ver,")
print("  não necessariamente o que você PRECISA ver.")
print("- Se você só vê futebol, vai achar que o mundo")
print("  inteiro só fala de futebol. Isso é uma BOLHA.")
print("=" * 50)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. O que acontece se adicionarmos um conteúdo de uma
#    categoria que o usuário NUNCA viu?
# 2. Como o algoritmo poderia ser modificado para recomendar
#    algo que o usuário NÃO conhece, mas poderia gostar?
# 3. Quem lucra com esse algoritmo? O usuário ou a plataforma?
# ============================================================

# ============================================================
# SIMULADOR DE COLETA E PERFILAMENTO DE DADOS
# ============================================================
#
# Este código simula como uma plataforma coleta dados sobre
# você e constrói um "perfil" para te classificar e te vender
# para anunciantes.
#
# NA VIDA REAL: isso acontece em milissegundos, com milhares
# de variáveis, sem você saber, sem você consentir de verdade.
# ============================================================

# 1. COLETA DE DADOS (o que a plataforma "raspa" de você)
# Tudo o que você faz, clica, curte, compartilha, pesquisa,
# onde você está, com quem você está, a que horas...

class ColetorDeDados:
    """
    Simula a coleta de dados de um usuário.
    Na vida real, isso é feito por cookies, pixels de rastreamento,
    SDKs de terceiros, e centenas de outras tecnologias invisíveis.
    """
    def __init__(self):
        # Banco de dados do usuário (começa vazio)
        self.dados_usuario = {
            "informacoes_basicas": {},
            "comportamento": [],
            "interesses": [],
            "localizacao": [],
            "dispositivos": []
        }

    def coletar_dados_basicos(self, nome, idade, genero, cidade):
        """
        Coleta dados que você fornece "voluntariamente" ao se cadastrar.
        """
        self.dados_usuario["informacoes_basicas"] = {
            "nome": nome,
            "idade": idade,
            "genero": genero,
            "cidade": cidade,
            "data_coleta": "hoje"  # na vida real: timestamp exato
        }
        print(f"📥 Coletados dados básicos de {nome}")

    def rastrear_clique(self, item, categoria, tempo_gasto):
        """
        Rastreia o que você clica, quanto tempo você gasta,
        e o que isso diz sobre você.
        """
        registro = {
            "item": item,
            "categoria": categoria,
            "tempo_gasto": tempo_gasto,  # em segundos
            "timestamp": "agora"
        }
        self.dados_usuario["comportamento"].append(registro)
        # Atualiza interesses com base no comportamento
        if categoria not in self.dados_usuario["interesses"]:
            self.dados_usuario["interesses"].append(categoria)
        print(f"🖱️ Clique rastreado: {item} ({categoria}) - {tempo_gasto}s")

    def rastrear_localizacao(self, latitude, longitude):
        """
        Rastreia onde você está. Sim, seu celular faz isso o tempo todo.
        """
        self.dados_usuario["localizacao"].append({
            "lat": latitude,
            "lon": longitude,
            "timestamp": "agora"
        })
        print(f"📍 Localização registrada: {latitude}, {longitude}")

    def obter_perfil(self):
        """
        Constrói o perfil do usuário com base em todos os dados coletados.
        Este é o "clone digital" que a plataforma vende para anunciantes.
        """
        perfil = {
            "nome": self.dados_usuario["informacoes_basicas"].get("nome", "Anônimo"),
            "idade": self.dados_usuario["informacoes_basicas"].get("idade", "Desconhecida"),
            "cidade": self.dados_usuario["informacoes_basicas"].get("cidade", "Desconhecida"),
            "interesses_identificados": list(set(self.dados_usuario["interesses"])),
            "total_cliques": len(self.dados_usuario["comportamento"]),
            "tempo_medio_por_clique": self._calcular_tempo_medio(),
            "locais_visitados": len(self.dados_usuario["localizacao"]),
            "classificacao_anunciante": self._classificar_para_anuncios()
        }
        return perfil

    def _calcular_tempo_medio(self):
        """Calcula o tempo médio gasto por clique."""
        if not self.dados_usuario["comportamento"]:
            return 0
        total = sum(registro["tempo_gasto"] for registro in self.dados_usuario["comportamento"])
        return total / len(self.dados_usuario["comportamento"])

    def _classificar_para_anuncios(self):
        """
        Classifica o usuário para segmentação de anúncios.
        Isso é o que as plataformas VENDEM.
        """
        interesses = set(self.dados_usuario["interesses"])
        if "futebol" in interesses and "jogos" in interesses:
            return "PÚBLICO ALVO: Jovens gamers + esportes"
        elif "moda" in interesses or "beleza" in interesses:
            return "PÚBLICO ALVO: Moda e estilo de vida"
        elif "tecnologia" in interesses or "programacao" in interesses:
            return "PÚBLICO ALVO: Tech enthusiasts"
        else:
            return "PÚBLICO ALVO: Geral (menos valioso para anunciantes)"

# ============================================================
# SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🕵️ SIMULADOR DE COLETA DE DADOS")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO do que acontece")
print(" na vida real, o tempo todo, com você.")
print(" A diferença? Na vida real, você não vê o código.")
print("=" * 60)

# Criando o "coletor"
coletor = ColetorDeDados()

# 1. Você se cadastra (fornece dados "voluntariamente")
print("\n📝 PASSO 1: Você se cadastra na plataforma")
print("-" * 40)
coletor.coletar_dados_basicos("João Silva", 16, "Masculino", "Curitiba")

# 2. Você começa a usar a plataforma (clica, curte, compartilha)
print("\n🖱️ PASSO 2: Você interage com a plataforma")
print("-" * 40)
coletor.rastrear_clique("Melhores gols de 2024", "futebol", 45)
coletor.rastrear_clique("Gameplay de novo jogo", "jogos", 120)
coletor.rastrear_clique("Tutorial de Python", "programacao", 90)
coletor.rastrear_clique("Notícia sobre política", "noticias", 15)  # pouco tempo = pouco interesse
coletor.rastrear_clique("Review de tênis Nike", "moda", 30)

# 3. A plataforma rastreia sua localização
print("\n📍 PASSO 3: A plataforma rastreia sua localização")
print("-" * 40)
coletor.rastrear_localizacao(-25.4284, -49.2733)  # Curitiba
coletor.rastrear_localizacao(-23.5505, -46.6333)  # São Paulo (você viajou?)

# 4. A plataforma constrói seu PERFIL
print("\n📊 PASSO 4: A plataforma constrói seu PERFIL DIGITAL")
print("=" * 60)
perfil = coletor.obter_perfil()

print(f"\n👤 PERFIL DO USUÁRIO:")
print(f"  Nome: {perfil['nome']}")
print(f"  Idade: {perfil['idade']} anos")
print(f"  Cidade: {perfil['cidade']}")
print(f"\n🎯 INTERESSES IDENTIFICADOS:")
for interesse in perfil['interesses_identificados']:
    print(f"  - {interesse}")
print(f"\n📈 MÉTRICAS DE COMPORTAMENTO:")
print(f"  Total de cliques rastreados: {perfil['total_cliques']}")
print(f"  Tempo médio por clique: {perfil['tempo_medio_por_clique']:.1f} segundos")
print(f"  Locais visitados (rastreados): {perfil['locais_visitados']}")
print(f"\n💰 CLASSIFICAÇÃO PARA ANÚNCIOS:")
print(f"  {perfil['classificacao_anunciante']}")

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- A plataforma SABE mais sobre você do que você imagina.")
print("- Esse perfil é VENDIDO para anunciantes.")
print("- Você não é o cliente. Você é o PRODUTO.")
print("- E o pior? Você deu esses dados DE GRAÇA.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Liste 10 coisas que a plataforma sabe sobre você
#    que você NUNCA contou a ela diretamente.
# 2. O que você pode fazer para reduzir a coleta de dados?
# 3. Pesquise: o que é a LGPD e como ela te protege?
# ============================================================

# ============================================================
# SIMULADOR DE GATILHOS EMOCIONAIS
# ============================================================
#
# Este código simula como as plataformas usam gatilhos
# emocionais para prender sua atenção.
#
# NA VIDA REAL: isso é chamado de "design persuasivo" ou
# "arquitetura da dependência". E funciona. Muito bem.
# ============================================================

import random
import time

class PlataformaDeAtencao:
    """
    Simula uma plataforma de rede social que usa gatilhos
    emocionais para maximizar o tempo de tela do usuário.
    """
    def __init__(self, nome):
        self.nome = nome
        self.gatilhos_ativos = []
        self.tempo_total = 0
        self.interacoes = 0

    def ativar_gatilho(self, gatilho):
        """
        Ativa um gatilho emocional na plataforma.
        Cada gatilho é uma estratégia de design para te prender.
        """
        self.gatilhos_ativos.append(gatilho)
        print(f"🔔 Gatilho ativado: {gatilho['nome']}")
        print(f"   Descrição: {gatilho['descricao']}")

    def simular_uso(self, minutos):
        """
        Simula o uso da plataforma por X minutos.
        A cada interação, um gatilho é acionado.
        """
        print(f"\n📱 Usando {self.nome} por {minutos} minutos...")
        print("-" * 50)
        for minuto in range(minutos):
            # A cada minuto, um gatilho pode ser acionado
            if random.random() < 0.4:  # 40% de chance por minuto
                gatilho = random.choice(self.gatilhos_ativos)
                self._acionar_gatilho(gatilho)
                self.interacoes += 1
            self.tempo_total += 1
            time.sleep(0.1)  # só para efeito de simulação
        print("-" * 50)
        print(f"⏱️ Tempo total: {self.tempo_total} minutos")
        print(f"🔄 Interações: {self.interacoes}")

    def _acionar_gatilho(self, gatilho):
        """
        Aciona um gatilho emocional específico.
        Cada gatilho tem um efeito psicológico diferente.
        """
        print(f"\n⚡ GATILHO ACIONADO: {gatilho['nome']}")
        print(f"   {gatilho['efeito']}")
        # Alguns gatilhos têm efeitos colaterais (ansiedade, FOMO, etc.)
        if gatilho['nome'] == "Notificação":
            print("   🔴 Você recebeu uma notificação! (você precisa ver agora)")
        elif gatilho['nome'] == "Rolagem Infinita":
            print("   🔄 Mais conteúdo está carregando... e mais... e mais...")
        elif gatilho['nome'] == "Curtidas":
            print("   ❤️ Alguém curtiu sua foto! (você se sente validado)")
        elif gatilho['nome'] == "Comparação Social":
            print("   👀 Seu amigo está viajando! (por que você não está lá?)")
        elif gatilho['nome'] == "FOMO":
            print("   😱 Você está perdendo algo importante! (todo mundo está vendo)")
        elif gatilho['nome'] == "Recompensa Variável":
            print("   🎰 Você ganhou um prêmio! (mas só se continuar rolando)")

# ============================================================
# CATÁLOGO DE GATILHOS EMOCIONAIS
# ============================================================
gatilhos = [
    {
        "nome": "Notificação",
        "descricao": "Alertas que interrompem sua atenção e criam urgência",
        "efeito": "Você sente a necessidade de verificar imediatamente"
    },
    {
        "nome": "Rolagem Infinita",
        "descricao": "Conteúdo que nunca acaba sempre tem mais um pouco",
        "efeito": "Você perde a noção do tempo e continua rolando"
    },
    {
        "nome": "Curtidas",
        "descricao": "Validação social em forma de coração",
        "efeito": "Você busca aprovação e volta para ver quantas curtiu"
    },
    {
        "nome": "Comparação Social",
        "descricao": "Mostrar a vida perfeita dos outros",
        "efeito": "Você se sente inadequado e continua olhando"
    },
    {
        "nome": "FOMO",
        "descricao": "Fear Of Missing Out medo de estar perdendo algo",
        "efeito": "Você fica para não perder nada (e perde tudo)"
    },
    {
        "nome": "Recompensa Variável",
        "descricao": "Prêmios imprevisíveis como um caça-níquel",
        "efeito": "Você continua porque \"dessa vez pode ser diferente\""
    }
]

# ============================================================
# SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🧠 SIMULADOR DE ECONOMIA DA ATENÇÃO")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO do que as")
print(" plataformas fazem com você o tempo todo.")
print(" A diferença? Na vida real, você não vê os gatilhos.")
print("=" * 60)

# Criando a plataforma
plataforma = PlataformaDeAtencao("InstaBookTok")

# Ativando os gatilhos (na vida real, todos estão ativos o tempo todo)
print("\n🔧 CONFIGURANDO GATILHOS...")
print("-" * 40)
for gatilho in gatilhos:
    plataforma.ativar_gatilho(gatilho)

# Simulando o uso
print("\n" + "=" * 60)
plataforma.simular_uso(10)  # 10 minutos de uso

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- Você entrou para ver uma coisa e ficou 10 minutos.")
print("- Cada minuto, um gatilho diferente te prendeu.")
print("- Você não percebeu o tempo passar.")
print("- Isso não é acidente. É engenharia.")
print("- E a pergunta que fica: quem está no controle,")
print("  você ou o algoritmo?")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Quais gatilhos você reconhece no seu uso diário?
# 2. Quanto tempo você gasta por dia em redes sociais?
# 3. O que você pode fazer para retomar o controle?
# 4. Pesquise: o que é "design persuasivo"?
# ============================================================

# ============================================================
# SIMULADOR DE BOLHAS E FAKE NEWS
# ============================================================
#
# Este código simula como algoritmos de recomendação criam
# bolhas e como fake news se espalham dentro dessas bolhas.
#
# NA VIDA REAL: isso acontece em escala global, em milissegundos,
# com bilhões de pessoas, sem que ninguém veja o código.
# ============================================================

import random

# ============================================================
# 1. SIMULAÇÃO DE BOLHA DIGITAL
# ============================================================
class BolhaDigital:
    """
    Simula uma bolha digital um grupo de pessoas que só
    consomem conteúdo que confirma suas crenças.
    """
    def __init__(self, nome, crenca_central):
        self.nome = nome
        self.crenca_central = crenca_central  # ex: "futebol é o melhor esporte"
        self.membros = []
        self.conteudos_consumidos = []

    def adicionar_membro(self, pessoa):
        """Adiciona uma pessoa à bolha."""
        self.membros.append(pessoa)
        print(f"👤 {pessoa} entrou na bolha '{self.nome}'")

    def recomendar_conteudo(self, conteudo):
        """
        Recomenda um conteúdo apenas se ele estiver alinhado
        com a crença central da bolha.
        """
        if conteudo["alinhamento"] == self.crenca_central:
            self.conteudos_consumidos.append(conteudo)
            print(f"📰 BOLHA '{self.nome}' consumiu: {conteudo['titulo']}")
            return True
        else:
            print(f"🚫 BOLHA '{self.nome}' REJEITOU: {conteudo['titulo']}")
            return False

# ============================================================
# 2. SIMULAÇÃO DE FAKE NEWS
# ============================================================
class FakeNews:
    """
    Simula uma notícia falsa, com seus atributos e seu potencial
    de viralização dentro de bolhas.
    """
    def __init__(self, titulo, conteudo, alinhamento, nivel_apelo_emocional, fonte):
        self.titulo = titulo
        self.conteudo = conteudo
        self.alinhamento = alinhamento  # ex: "futebol é o melhor esporte"
        self.nivel_apelo_emocional = nivel_apelo_emocional  # 0 a 10
        self.fonte = fonte
        self.viralizacao = 0
        self.compartilhamentos = 0

    def tentar_viralizar(self, bolha):
        """
        Tenta viralizar dentro de uma bolha.
        Quanto maior o apelo emocional, maior a chance.
        """
        if bolha.crenca_central == self.alinhamento:
            # Dentro da bolha, a fake news se espalha fácil
            chance = self.nivel_apelo_emocional / 10
            if random.random() < chance:
                self.viralizacao += 1
                self.compartilhamentos += random.randint(1, 10)
                print(f"🔥 FAKE NEWS VIRALIZOU na bolha '{bolha.nome}'!")
                print(f"   Título: {self.titulo}")
                print(f"   Compartilhamentos: +{self.compartilhamentos}")
                return True
        return False

# ============================================================
# 3. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🎭 SIMULADOR DE BOLHAS E FAKE NEWS")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO do que acontece")
print(" na vida real, o tempo todo, com milhões de pessoas.")
print(" A diferença? Na vida real, você não vê o mecanismo.")
print("=" * 60)

# Criando bolhas
print("\n📌 CRIANDO BOLHAS...")
print("-" * 40)
bolha_futebol = BolhaDigital("Futebolistas", "futebol é o melhor esporte")
bolha_politica = BolhaDigital("Política", "política é sobre poder")
bolha_tecnologia = BolhaDigital("Tech Lovers", "tecnologia salva o mundo")

# Adicionando membros
bolha_futebol.adicionar_membro("João")
bolha_futebol.adicionar_membro("Pedro")
bolha_futebol.adicionar_membro("Maria")
bolha_politica.adicionar_membro("Ana")
bolha_politica.adicionar_membro("Carlos")
bolha_tecnologia.adicionar_membro("Lucas")
bolha_tecnologia.adicionar_membro("Julia")

# Criando conteúdos (alguns verdadeiros, outros falsos)
print("\n📰 CRIANDO CONTEÚDOS...")
print("-" * 40)
conteudos = [
    {
        "titulo": "Brasil vence campeonato de futebol",
        "alinhamento": "futebol é o melhor esporte",
        "verdadeiro": True
    },
    {
        "titulo": "Jogador famoso traiu a esposa com modelo",
        "alinhamento": "futebol é o melhor esporte",
        "verdadeiro": False  # FAKE NEWS!
    },
    {
        "titulo": "Político roubou dinheiro público",
        "alinhamento": "política é sobre poder",
        "verdadeiro": True
    },
    {
        "titulo": "Político adversário é alienígena",
        "alinhamento": "política é sobre poder",
        "verdadeiro": False  # FAKE NEWS!
    },
    {
        "titulo": "Novo smartphone revoluciona o mundo",
        "alinhamento": "tecnologia salva o mundo",
        "verdadeiro": True
    },
    {
        "titulo": "Inteligência Artificial vai destruir a humanidade",
        "alinhamento": "tecnologia salva o mundo",
        "verdadeiro": False  # FAKE NEWS!
    }
]

# Simulando recomendações e viralização
print("\n🔄 SIMULANDO RECOMENDAÇÕES E VIRALIZAÇÃO...")
print("=" * 60)
for conteudo in conteudos:
    print(f"\n📌 Analisando: '{conteudo['titulo']}'")
    print(f"   Alinhamento: {conteudo['alinhamento']}")
    print(f"   Verdadeiro: {conteudo['verdadeiro']}")
    print("-" * 40)
    # Recomendar para cada bolha
    for bolha in [bolha_futebol, bolha_politica, bolha_tecnologia]:
        if bolha.crenca_central == conteudo["alinhamento"]:
            if conteudo["verdadeiro"]:
                print(f"✅ BOLHA '{bolha.nome}' consumiu conteúdo VERDADEIRO")
            else:
                print(f"⚠️ BOLHA '{bolha.nome}' consumiu FAKE NEWS!")
                # Fake news tem mais chance de viralizar
                if random.random() < 0.7:  # 70% de chance
                    print(f"🔥 FAKE NEWS VIRALIZOU na bolha '{bolha.nome}'!")

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- Dentro da bolha, você só vê o que confirma suas crenças.")
print("- Fake news se espalham MAIS RAPIDO que verdades.")
print("- Por quê? Porque fake news têm MAIS APELO EMOCIONAL.")
print("- E mais apelo emocional = mais cliques = mais dinheiro.")
print("- A pergunta: você está dentro de uma bolha?")
print("  E como você sai dela?")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Liste 3 fontes de informação que você consome regularmente.
# 2. Essas fontes são diversas ou estão todas na mesma bolha?
# 3. Crie um ALGORITMO (passo a passo) para identificar fake news.
# 4. Teste seu algoritmo com uma notícia real.
# ============================================================

# ============================================================
# SIMULADOR DE APLICAÇÃO DA LGPD
# ============================================================
#
# Este código simula como a LGPD pode ser aplicada na prática.
# Ele mostra como você pode exercer seus direitos sobre seus dados.
#
# NA VIDA REAL: você tem esses direitos. Mas precisa conhecê-los
# e exigi-los. A lei não age sozinha você age por ela.
# ============================================================

# ============================================================
# 1. BANCO DE DADOS DE UMA EMPRESA (simulado)
# ============================================================
class BancoDeDados:
    """
    Simula o banco de dados de uma empresa que coleta dados de usuários.
    """
    def __init__(self, nome_empresa):
        self.nome_empresa = nome_empresa
        self.usuarios = {}
        self.logs_acesso = []

    def cadastrar_usuario(self, nome, email, telefone, cpf, dados_sensiveis=None):
        """Cadastra um usuário no banco de dados."""
        self.usuarios[email] = {
            "nome": nome,
            "email": email,
            "telefone": telefone,
            "cpf": cpf,
            "dados_sensiveis": dados_sensiveis or {},
            "data_cadastro": "hoje"
        }
        print(f"✅ Usuário {nome} cadastrado na {self.nome_empresa}")

    def acessar_dados(self, email, solicitante):
        """Simula o acesso a dados (registra quem acessou)."""
        if email in self.usuarios:
            self.logs_acesso.append({
                "email": email,
                "solicitante": solicitante,
                "data": "agora"
            })
            print(f"🔍 Dados de {email} acessados por {solicitante}")
            return self.usuarios[email]
        else:
            print(f"❌ Usuário {email} não encontrado")
            return None

# ============================================================
# 2. SIMULAÇÃO DOS DIREITOS DO TITULAR (LGPD)
# ============================================================
class DireitosTitular:
    """
    Simula os direitos que você tem como titular de dados pessoais,
    de acordo com a LGPD (Lei nº 13.709/2018).
    """
    def __init__(self, banco_dados):
        self.banco = banco_dados

    def direito_acesso(self, email):
        """
        Direito de acesso: você pode solicitar que a empresa
        te mostre TODOS os dados que ela tem sobre você.
        """
        print(f"\n📋 EXERCENDO DIREITO DE ACESSO - {email}")
        print("-" * 40)
        dados = self.banco.acessar_dados(email, "Titular (você)")
        if dados:
            print("\n📊 DADOS QUE A EMPRESA TEM SOBRE VOCÊ:")
            for chave, valor in dados.items():
                print(f"  {chave}: {valor}")
            print("\n✅ Direito de acesso exercido com sucesso!")
            return dados
        return None

    def direito_correcao(self, email, campo, novo_valor):
        """
        Direito de correção: você pode pedir para corrigir
        dados incompletos, inexatos ou desatualizados.
        """
        print(f"\n✏️ EXERCENDO DIREITO DE CORREÇÃO - {email}")
        print("-" * 40)
        if email in self.banco.usuarios:
            if campo in self.banco.usuarios[email]:
                self.banco.usuarios[email][campo] = novo_valor
                print(f"✅ Campo '{campo}' atualizado para: {novo_valor}")
                print("✅ Direito de correção exercido com sucesso!")
            else:
                print(f"❌ Campo '{campo}' não encontrado")
        else:
            print(f"❌ Usuário {email} não encontrado")

    def direito_exclusao(self, email):
        """
        Direito de exclusão: você pode pedir para a empresa
        excluir seus dados pessoais (com algumas exceções).
        """
        print(f"\n🗑️ EXERCENDO DIREITO DE EXCLUSÃO - {email}")
        print("-" * 40)
        if email in self.banco.usuarios:
            confirmacao = input(f"Tem certeza que quer excluir todos os dados de {email}? (s/n): ")
            if confirmacao.lower() == 's':
                del self.banco.usuarios[email]
                print("✅ Dados excluídos com sucesso!")
                print("✅ Direito de exclusão exercido com sucesso!")
            else:
                print("❌ Exclusão cancelada.")
        else:
            print(f"❌ Usuário {email} não encontrado")

    def direito_portabilidade(self, email, nova_empresa):
        """
        Direito de portabilidade: você pode pedir para a empresa
        transferir seus dados para outra empresa.
        """
        print(f"\n📤 EXERCENDO DIREITO DE PORTABILIDADE - {email}")
        print("-" * 40)
        dados = self.banco.acessar_dados(email, "Titular (você)")
        if dados:
            print(f"📦 Dados de {email} sendo transferidos para {nova_empresa}...")
            print("✅ Dados transferidos com sucesso!")
            print("✅ Direito de portabilidade exercido com sucesso!")

    def direito_revogacao_consentimento(self, email):
        """
        Direito de revogação do consentimento: você pode retirar
        o consentimento que deu para o tratamento de dados.
        """
        print(f"\n🔄 EXERCENDO DIREITO DE REVOGAÇÃO DE CONSENTIMENTO - {email}")
        print("-" * 40)
        print("⚠️ Você está revogando o consentimento para o tratamento de seus dados.")
        print(" A empresa deve parar de tratar seus dados imediatamente.")
        confirmacao = input("Confirma a revogação? (s/n): ")
        if confirmacao.lower() == 's':
            print("✅ Consentimento revogado com sucesso!")
            print("✅ A empresa deve parar de tratar seus dados.")
        else:
            print("❌ Revogação cancelada.")

# ============================================================
# 3. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("⚖️ SIMULADOR DE APLICAÇÃO DA LGPD")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO dos seus direitos")
print(" sob a Lei Geral de Proteção de Dados (LGPD).")
print(" Na vida real, você TEM esses direitos.")
print(" A diferença? Você precisa EXIGI-LOS.")
print("=" * 60)

# Criando o banco de dados de uma empresa
empresa = BancoDeDados("TechData S.A.")

# Cadastrando um usuário (você)
print("\n📝 CADASTRANDO USUÁRIO...")
print("-" * 40)
empresa.cadastrar_usuario(
    nome="João Silva",
    email="joao@email.com",
    telefone="(41) 99999-9999",
    cpf="123.456.789-00",
    dados_sensiveis={
        "orientacao_politica": "não informado",
        "religiao": "não informado"
    }
)

# Criando o objeto de direitos
direitos = DireitosTitular(empresa)

# ============================================================
# SIMULANDO O EXERCÍCIO DOS DIREITOS
# ============================================================
print("\n" + "=" * 60)
print("🔑 EXERCENDO SEUS DIREITOS LGPD")
print("=" * 60)

# 1. Direito de acesso
print("\n1️⃣ DIREITO DE ACESSO")
print("-" * 40)
direitos.direito_acesso("joao@email.com")

# 2. Direito de correção
print("\n2️⃣ DIREITO DE CORREÇÃO")
print("-" * 40)
direitos.direito_correcao("joao@email.com", "telefone", "(41) 88888-8888")

# 3. Direito de portabilidade
print("\n3️⃣ DIREITO DE PORTABILIDADE")
print("-" * 40)
direitos.direito_portabilidade("joao@email.com", "NovaData Inc.")

# 4. Direito de revogação de consentimento
print("\n4️⃣ DIREITO DE REVOGAÇÃO DE CONSENTIMENTO")
print("-" * 40)
direitos.direito_revogacao_consentimento("joao@email.com")

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- Você sabia que tem TODOS esses direitos?")
print("- A LGPD existe. Mas ela só funciona se você a CONHECE.")
print("- E mais: ela só funciona se você a EXIGE.")
print("- Seus dados são SEUS. E só seus.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Pesquise: o que é a ANPD (Autoridade Nacional de Proteção de Dados)?
# 2. Como fazer uma reclamação à ANPD?
# 3. Quais são as multas previstas para violação da LGPD?
# 4. Compare a LGPD com a GDPR (Lei Europeia).
# ============================================================

# ============================================================
# SIMULADOR DE CYBERBULLYING E ROTEIRO DE DENÚNCIA
# ============================================================
#
# Este código simula situações de cyberbullying e oferece
# um passo a passo para denúncia e apoio à vítima.
#
# NA VIDA REAL: o cyberbullying acontece o tempo todo.
# A diferença? Muitas vezes, as vítimas não sabem o que fazer.
# Aqui, você vai aprender.
# ============================================================

# ============================================================
# 1. SIMULAÇÃO DE SITUAÇÕES DE CYBERBULLYING
# ============================================================
class CyberbullyingSimulator:
    """
    Simula situações de cyberbullying para que os alunos
    possam praticar a identificação e a resposta adequada.
    """
    def __init__(self):
        self.situacoes = []
        self._carregar_situacoes()

    def _carregar_situacoes(self):
        """Carrega situações de cyberbullying para simulação."""
        self.situacoes = [
            {
                "id": 1,
                "titulo": "Humilhação em grupo",
                "descricao": "Alguém postou uma foto sua em um grupo de WhatsApp e fez comentários humilhantes sobre sua aparência.",
                "papel": "vítima",
                "impacto": "Vergonha, isolamento, ansiedade"
            },
            {
                "id": 2,
                "titulo": "Compartilhamento de foto sem permissão",
                "descricao": "Uma foto sua foi compartilhada em redes sociais sem sua permissão, com comentários maldosos.",
                "papel": "vítima",
                "impacto": "Exposição, constrangimento, medo"
            },
            {
                "id": 3,
                "titulo": "Perseguição online",
                "descricao": "Alguém está te enviando mensagens ofensivas repetidamente, mesmo depois de você pedir para parar.",
                "papel": "vítima",
                "impacto": "Medo, ansiedade, sensação de insegurança"
            },
            {
                "id": 4,
                "titulo": "Exclusão virtual",
                "descricao": "Você foi excluído de um grupo e está sendo ignorado por colegas que antes eram seus amigos.",
                "papel": "vítima",
                "impacto": "Solidão, tristeza, baixa autoestima"
            },
            {
                "id": 5,
                "titulo": "Difamação",
                "descricao": "Alguém está espalhando mentiras sobre você nas redes sociais.",
                "papel": "vítima",
                "impacto": "Reputação manchada, ansiedade, depressão"
            }
        ]

    def mostrar_situacao(self, id_situacao):
        """Mostra uma situação específica."""
        for situacao in self.situacoes:
            if situacao["id"] == id_situacao:
                print(f"\n📌 SITUAÇÃO: {situacao['titulo']}")
                print(f"   Descrição: {situacao['descricao']}")
                print(f"   Impacto: {situacao['impacto']}")
                return situacao
        print("❌ Situação não encontrada")
        return None

# ============================================================
# 2. ROTEIRO DE DENÚNCIA (PASSO A PASSO)
# ============================================================
class RoteiroDenuncia:
    """
    Fornece um passo a passo (algoritmo) para denunciar
    situações de cyberbullying.
    """
    def __init__(self):
        self.passos = [
            {
                "numero": 1,
                "acao": "SALVE AS PROVAS",
                "descricao": "Tire prints, grave vídeos, salve mensagens. Tudo o que comprova o abuso."
            },
            {
                "numero": 2,
                "acao": "BLOQUEIE O AGRESSOR",
                "descricao": "Bloqueie a pessoa em todas as plataformas para evitar novos ataques."
            },
            {
                "numero": 3,
                "acao": "DENUNCIE NA PLATAFORMA",
                "descricao": "Use as ferramentas de denúncia da plataforma (WhatsApp, Instagram, TikTok, etc.)."
            },
            {
                "numero": 4,
                "acao": "COMUNIQUE À ESCOLA",
                "descricao": "Procure a direção ou a orientação educacional. A escola tem o dever de agir."
            },
            {
                "numero": 5,
                "acao": "PROCURE AJUDA PROFISSIONAL",
                "descricao": "Converse com um psicólogo, um familiar ou um amigo de confiança."
            },
            {
                "numero": 6,
                "acao": "DENUNCIE À POLÍCIA",
                "descricao": "Em casos graves, procure a Delegacia de Crimes Cibernéticos ou o Disque 100."
            }
        ]

    def mostrar_roteiro(self):
        """Mostra o passo a passo completo para denúncia."""
        print("\n📋 ROTEIRO DE DENÚNCIA PASSO A PASSO")
        print("=" * 50)
        for passo in self.passos:
            print(f"\n{passo['numero']}. {passo['acao']}")
            print(f"   {passo['descricao']}")
        print("\n" + "=" * 50)
        print("💡 LEMBRE-SE:")
        print("- Você não está sozinho.")
        print("- O cyberbullying NÃO é culpa sua.")
        print("- Pedir ajuda NÃO é fraqueza é coragem.")
        print("- Denunciar NÃO é dedurar é proteger.")
        print("=" * 50)

# ============================================================
# 3. TESTE DE EMPATIA
# ============================================================
class TesteEmpatia:
    """
    Um teste rápido para refletir sobre empatia online.
    """
    def __init__(self):
        self.perguntas = [
            {
                "pergunta": "Antes de postar algo sobre alguém, você pensa como ela se sentiria?",
                "reflexao": "A empatia é a base da convivência digital. Pense antes de postar."
            },
            {
                "pergunta": "Se você visse alguém sendo humilhado online, o que faria?",
                "reflexao": "Ser testemunha também é uma escolha. Você pode ajudar ou pode se calar."
            },
            {
                "pergunta": "Você já compartilhou algo sem verificar se era verdade?",
                "reflexao": "Compartilhar fake news também pode machucar. Verifique antes."
            },
            {
                "pergunta": "Você já excluiu alguém de um grupo ou rede social sem motivo?",
                "reflexao": "A exclusão virtual pode ser dolorosa. Pense no impacto."
            }
        ]

    def aplicar_teste(self):
        """Aplica o teste de empatia."""
        print("\n🧠 TESTE DE EMPATIA DIGITAL")
        print("=" * 50)
        print("Responda mentalmente a cada pergunta:")
        for i, item in enumerate(self.perguntas, 1):
            print(f"\n{i}. {item['pergunta']}")
            print(f"   💭 {item['reflexao']}")
        print("\n" + "=" * 50)
        print("💡 REFLEXÃO FINAL:")
        print(" A empatia não é um sentimento é uma escolha.")
        print(" E você faz essa escolha a cada post, a cada comentário.")
        print("=" * 50)

# ============================================================
# 4. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("💬 SIMULADOR DE CYBERBULLYING E ROTEIRO DE DENÚNCIA")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO.")
print(" O cyberbullying é REAL e acontece o tempo todo.")
print(" O objetivo aqui é APRENDER a identificar e agir.")
print("=" * 60)

# Criando o simulador
simulador = CyberbullyingSimulator()
roteiro = RoteiroDenuncia()
teste = TesteEmpatia()

# Mostrando uma situação
print("\n📌 EXEMPLO DE SITUAÇÃO DE CYBERBULLYING")
print("-" * 40)
simulador.mostrar_situacao(1)

# Mostrando o roteiro de denúncia
print("\n" + "=" * 60)
roteiro.mostrar_roteiro()

# Aplicando o teste de empatia
print("\n" + "=" * 60)
teste.aplicar_teste()

print("\n" + "=" * 60)
print("💡 REFLEXÃO FINAL:")
print("- O cyberbullying não é 'brincadeira' é violência.")
print("- O que você faz online quando ninguém está vendo")
print("  é o que realmente define quem você é.")
print("- E tem consequências.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Crie um plano de ação para situações de cyberbullying na escola.
# 2. Pesquise: quais são as leis contra cyberbullying no Brasil?
# 3. Crie uma campanha de conscientização sobre cyberbullying.
# ============================================================

# ============================================================
# PLANEJADOR DE PROJETO COM OS 4 PILARES DO PC
# ============================================================
#
# Este código simula o planejamento de um projeto de
# conscientização digital usando os 4 Pilares do Pensamento
# Computacional.
#
# O objetivo: transformar um problema complexo em uma solução
# estruturada, passo a passo.
# ============================================================

# ============================================================
# 1. DEFINIÇÃO DO PROBLEMA
# ============================================================
class Problema:
    """
    Representa um problema da Cultura Digital que precisa ser resolvido.
    """
    def __init__(self, nome, descricao, impacto, publico_alvo):
        self.nome = nome
        self.descricao = descricao
        self.impacto = impacto
        self.publico_alvo = publico_alvo
        self.causas = []
        self.consequencias = []

    def adicionar_causa(self, causa):
        """Adiciona uma causa do problema."""
        self.causas.append(causa)

    def adicionar_consequencia(self, consequencia):
        """Adiciona uma consequência do problema."""
        self.consequencias.append(consequencia)

    def resumo(self):
        """Mostra um resumo do problema."""
        print(f"\n📌 PROBLEMA: {self.nome}")
        print(f"   Descrição: {self.descricao}")
        print(f"   Impacto: {self.impacto}")
        print(f"   Público-alvo: {self.publico_alvo}")
        print(f"\n 🔍 Causas:")
        for causa in self.causas:
            print(f"   - {causa}")
        print(f"\n ⚠️ Consequências:")
        for cons in self.consequencias:
            print(f"   - {cons}")

# ============================================================
# 2. APLICAÇÃO DOS 4 PILARES
# ============================================================
class PlanejadorProjeto:
    """
    Aplica os 4 Pilares do Pensamento Computacional para
    planejar uma solução para um problema.
    """
    def __init__(self, problema):
        self.problema = problema
        self.decomposicao = []
        self.padroes = []
        self.abstracao = {}
        self.algoritmo = []

    # PILAR 1: DECOMPOSIÇÃO
    def decompor(self):
        """
        Divide o problema em partes menores e gerenciáveis.
        """
        print("\n🔨 PILAR 1: DECOMPOSIÇÃO")
        print("-" * 40)
        print("Dividindo o problema em partes menores...")
        # Exemplo de decomposição para um problema de "vício em redes sociais"
        if "vício" in self.problema.nome.lower() or "rede" in self.problema.nome.lower():
            partes = [
                "Causas do vício (gatilhos emocionais, design viciante)",
                "Comportamentos de dependência (tempo de tela, checagem compulsiva)",
                "Impactos na saúde mental (ansiedade, depressão, FOMO)",
                "Estratégias de prevenção e bem-estar digital",
                "Alternativas saudáveis de uso da tecnologia"
            ]
        # Exemplo para "fake news"
        elif "fake" in self.problema.nome.lower() or "desinformação" in self.problema.nome.lower():
            partes = [
                "Como as fake news são criadas",
                "Como as fake news se espalham (algoritmos, bolhas)",
                "Padrões de desinformação (títulos, fontes, imagens)",
                "Impactos das fake news na sociedade",
                "Estratégias de verificação e combate"
            ]
        # Exemplo para "cyberbullying"
        elif "cyber" in self.problema.nome.lower() or "bullying" in self.problema.nome.lower():
            partes = [
                "O que é cyberbullying (definição e formas)",
                "Perfil da vítima, do agressor e da testemunha",
                "Impactos psicológicos e sociais",
                "Canais de denúncia e suporte",
                "Estratégias de prevenção e educação"
            ]
        else:
            partes = [
                "Entendimento do problema (causas e contexto)",
                "Identificação dos atores envolvidos",
                "Análise dos impactos",
                "Mapeamento de soluções existentes",
                "Definição da solução proposta"
            ]
        self.decomposicao = partes
        for i, parte in enumerate(partes, 1):
            print(f" {i}. {parte}")
        return self.decomposicao

    # PILAR 2: RECONHECIMENTO DE PADRÕES
    def reconhecer_padroes(self):
        """
        Identifica padrões no problema.
        """
        print("\n🔍 PILAR 2: RECONHECIMENTO DE PADRÕES")
        print("-" * 40)
        print("Identificando padrões que se repetem...")
        # Padrões comuns em problemas de Cultura Digital
        padroes_comuns = [
            "Padrão de comportamento: ciclo de dependência (gatilho → ação → recompensa)",
            "Padrão de desinformação: apelo emocional + ausência de fontes",
            "Padrão de exclusão: isolamento progressivo do indivíduo",
            "Padrão de vigilância: coleta de dados em todos os momentos",
            "Padrão de manipulação: uso de dados para influenciar decisões"
        ]
        self.padroes = padroes_comuns
        for padrao in padroes_comuns:
            print(f" • {padrao}")
        return self.padroes

    # PILAR 3: ABSTRAÇÃO
    def abstrair(self):
        """
        Cria um modelo simplificado do problema.
        """
        print("\n🧠 PILAR 3: ABSTRAÇÃO")
        print("-" * 40)
        print("Criando um modelo simplificado do problema...")
        self.abstracao = {
            "problema_central": self.problema.nome,
            "modelo_simplificado": f"O problema '{self.problema.nome}' pode ser entendido como um ciclo de {len(self.decomposicao)} etapas interligadas, onde cada etapa alimenta a próxima.",
            "variaveis_chave": [
                "Comportamento do usuário",
                "Design da plataforma",
                "Algoritmos de recomendação",
                "Contexto social e cultural"
            ],
            "solucao_essencial": "Interromper o ciclo em um ou mais pontos críticos."
        }
        for chave, valor in self.abstracao.items():
            print(f" {chave}: {valor}")
        return self.abstracao

    # PILAR 4: ALGORITMOS
    def criar_algoritmo(self):
        """
        Desenvolve um passo a passo para a solução.
        """
        print("\n📋 PILAR 4: ALGORITMOS")
        print("-" * 40)
        print("Criando um passo a passo para a solução...")
        # Algoritmo genérico para projetos de conscientização
        algoritmo = [
            "1. Definir o público-alvo e o contexto",
            "2. Escolher o formato do protótipo (robô, campanha, jogo, app...)",
            "3. Definir os objetivos específicos do protótipo",
            "4. Criar um esboço/design do protótipo",
            "5. Desenvolver a primeira versão (MVP)",
            "6. Testar com usuários reais",
            "7. Coletar feedback e iterar",
            "8. Refinar e polir",
            "9. Lançar e divulgar",
            "10. Medir impacto e celebrar!"
        ]
        self.algoritmo = algoritmo
        for passo in algoritmo:
            print(f" {passo}")
        return self.algoritmo

# ============================================================
# 3. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🚀 PLANEJADOR DE PROJETO COM OS 4 PILARES DO PC")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Este é um simulador de planejamento.")
print(" Use os 4 Pilares para estruturar seu projeto.")
print(" O planejamento é a base de tudo.")
print("=" * 60)

# Criando um problema
print("\n📌 DEFININDO O PROBLEMA...")
print("-" * 40)
problema = Problema(
    nome="Vício em Redes Sociais",
    descricao="Uso excessivo e compulsivo de redes sociais, com impactos negativos na saúde mental e no bem-estar.",
    impacto="Ansiedade, depressão, isolamento social, perda de produtividade, distúrbios de sono.",
    publico_alvo="Adolescentes e jovens adultos (15-25 anos)"
)
problema.adicionar_causa("Design viciante das plataformas (rolagem infinita, notificações)")
problema.adicionar_causa("Algoritmos de recomendação que maximizam o tempo de tela")
problema.adicionar_causa("Pressão social e FOMO (Fear Of Missing Out)")
problema.adicionar_causa("Falta de educação digital e conscientização")
problema.adicionar_consequencia("Aumento da ansiedade e depressão")
problema.adicionar_consequencia("Isolamento social e perda de conexões reais")
problema.adicionar_consequencia("Queda no desempenho escolar e profissional")
problema.adicionar_consequencia("Distúrbios de sono e problemas de saúde física")
problema.resumo()

# Aplicando os 4 Pilares
print("\n" + "=" * 60)
print("🧩 APLICANDO OS 4 PILARES DO PENSAMENTO COMPUTACIONAL")
print("=" * 60)
planejador = PlanejadorProjeto(problema)

# Pilar 1: Decomposição
planejador.decompor()

# Pilar 2: Reconhecimento de Padrões
planejador.reconhecer_padroes()

# Pilar 3: Abstração
planejador.abstrair()

# Pilar 4: Algoritmos
planejador.criar_algoritmo()

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- Um bom projeto não começa com código.")
print("- Começa com uma PERGUNTA: 'Que problema eu quero resolver?'")
print("- Os 4 Pilares do PC são suas ferramentas.")
print("- Use-as. Abuse delas. Faça a diferença.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Escolha um problema da Cultura Digital.
# 2. Aplique os 4 Pilares do PC para planejar uma solução.
# 3. Apresente seu planejamento para a turma.
# 4. Comece a construir!
# ============================================================

# ============================================================
# SIMULADOR DE DESENVOLVIMENTO DE PROTÓTIPO
# ============================================================
#
# Este código simula o processo de desenvolvimento de um
# protótipo de conscientização digital.
#
# O objetivo: mostrar como o planejamento se transforma em
# código, design e impacto.
# ============================================================

import time
import random

# ============================================================
# 1. CLASSE BASE: PROTÓTIPO
# ============================================================
class Prototipo:
    """
    Classe base para todos os protótipos.
    """
    def __init__(self, nome, descricao, objetivo, publico_alvo):
        self.nome = nome
        self.descricao = descricao
        self.objetivo = objetivo
        self.publico_alvo = publico_alvo
        self.estado = "planejado"
        self.tarefas = []
        self.concluido = False
        self.bugs = []

    def adicionar_tarefa(self, tarefa):
        """Adiciona uma tarefa ao desenvolvimento."""
        self.tarefas.append({"tarefa": tarefa, "status": "pendente"})
        print(f"📋 Tarefa adicionada: {tarefa}")

    def executar_tarefa(self, tarefa):
        """Executa uma tarefa específica."""
        for t in self.tarefas:
            if t["tarefa"] == tarefa and t["status"] == "pendente":
                print(f"🔨 Executando: {tarefa}")
                time.sleep(0.5)  # simula o trabalho
                # 20% de chance de encontrar um bug
                if random.random() < 0.2:
                    bug = f"Bug em {tarefa}"
                    self.bugs.append(bug)
                    print(f"🐛 BUG ENCONTRADO: {bug}")
                    print("   Corrigindo...")
                    time.sleep(0.3)
                    print("   ✅ Bug corrigido!")
                t["status"] = "concluida"
                print(f"✅ Tarefa concluída: {tarefa}")
                return True
        print(f"❌ Tarefa '{tarefa}' não encontrada ou já concluída")
        return False

    def verificar_progresso(self):
        """Verifica o progresso do desenvolvimento."""
        total = len(self.tarefas)
        concluidas = sum(1 for t in self.tarefas if t["status"] == "concluida")
        progresso = (concluidas / total * 100) if total > 0 else 0
        print(f"\n📊 PROGRESSO: {progresso:.1f}% ({concluidas}/{total} tarefas)")
        if self.bugs:
            print(f"🐛 Bugs corrigidos: {len(self.bugs)}")
        return progresso

    def finalizar(self):
        """Finaliza o protótipo."""
        if self.verificar_progresso() == 100:
            self.estado = "concluido"
            self.concluido = True
            print("\n🎉 PROTÓTIPO FINALIZADO COM SUCESSO!")
            print(f"   Nome: {self.nome}")
            print(f"   Objetivo: {self.objetivo}")
            print(f"   Público-alvo: {self.publico_alvo}")
            return True
        else:
            print("\n⚠️ Protótipo ainda não está 100% completo.")
            print(" Continue trabalhando!")
            return False

# ============================================================
# 2. TIPOS DE PROTÓTIPO
# ============================================================
class RoboConscientizacao(Prototipo):
    """Robô que alerta sobre vício em redes sociais."""
    def __init__(self):
        super().__init__(
            nome="Robô Alerta Digital",
            descricao="Um robô que pisca e emite sons quando o usuário passa muito tempo no celular.",
            objetivo="Conscientizar sobre o tempo de tela e o vício digital.",
            publico_alvo="Jovens que passam mais de 4 horas por dia no celular."
        )
        self.tarefas = [
            {"tarefa": "Projetar o circuito no Tinkercad", "status": "pendente"},
            {"tarefa": "Programar o Arduino (LEDs e buzzer)", "status": "pendente"},
            {"tarefa": "Montar o protótipo físico", "status": "pendente"},
            {"tarefa": "Testar o funcionamento", "status": "pendente"},
            {"tarefa": "Criar a documentação", "status": "pendente"}
        ]

class JogoEducativo(Prototipo):
    """Jogo que ensina a identificar fake news."""
    def __init__(self):
        super().__init__(
            nome="Caça-Fake: O Jogo",
            descricao="Um jogo interativo onde o jogador deve identificar quais notícias são falsas.",
            objetivo="Ensinar a identificar fake news de forma lúdica e divertida.",
            publico_alvo="Adolescentes e jovens adultos."
        )
        self.tarefas = [
            {"tarefa": "Criar o design do jogo no Scratch", "status": "pendente"},
            {"tarefa": "Programar a lógica do jogo", "status": "pendente"},
            {"tarefa": "Criar os cenários e personagens", "status": "pendente"},
            {"tarefa": "Incluir feedback e pontuação", "status": "pendente"},
            {"tarefa": "Testar com usuários", "status": "pendente"}
        ]

class CampanhaDigital(Prototipo):
    """Campanha multiplataforma de conscientização."""
    def __init__(self):
        super().__init__(
            nome="PensaAntesDePostar",
            descricao="Uma campanha que usa vídeos, posts e infográficos para promover o uso consciente das redes.",
            objetivo="Reduzir a propagação de fake news e cyberbullying.",
            publico_alvo="Usuários de redes sociais de todas as idades."
        )
        self.tarefas = [
            {"tarefa": "Criar o conceito da campanha", "status": "pendente"},
            {"tarefa": "Produzir os vídeos", "status": "pendente"},
            {"tarefa": "Criar os infográficos", "status": "pendente"},
            {"tarefa": "Escrever os posts", "status": "pendente"},
            {"tarefa": "Planejar a divulgação", "status": "pendente"}
        ]

# ============================================================
# 3. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🔨 SIMULADOR DE DESENVOLVIMENTO DE PROTÓTIPO")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO do processo de")
print(" desenvolvimento de um protótipo.")
print(" Na vida real, é mais caótico e mais divertido.")
print("=" * 60)

# Escolhendo um protótipo
print("\n📌 ESCOLHA O TIPO DE PROTÓTIPO:")
print(" 1. Robô de Conscientização")
print(" 2. Jogo Educativo")
print(" 3. Campanha Digital")
try:
    escolha = int(input("\nDigite o número (1-3): "))
except ValueError:
    escolha = 1

if escolha == 1:
    prototipo = RoboConscientizacao()
elif escolha == 2:
    prototipo = JogoEducativo()
else:
    prototipo = CampanhaDigital()

print("\n" + "=" * 60)
print(f"🚀 PROTÓTIPO SELECIONADO: {prototipo.nome}")
print("=" * 60)
print(f"\n📝 Descrição: {prototipo.descricao}")
print(f"🎯 Objetivo: {prototipo.objetivo}")
print(f"👥 Público-alvo: {prototipo.publico_alvo}")

print("\n📋 TAREFAS DO PROJETO:")
for i, tarefa in enumerate(prototipo.tarefas, 1):
    print(f" {i}. {tarefa['tarefa']}")

# Simulando o desenvolvimento
print("\n" + "=" * 60)
print("🔨 INICIANDO O DESENVOLVIMENTO...")
print("=" * 60)

# Executando as tarefas uma por uma
for i, tarefa in enumerate(prototipo.tarefas, 1):
    print(f"\n📌 TAREFA {i}/{len(prototipo.tarefas)}")
    print("-" * 40)
    prototipo.executar_tarefa(tarefa["tarefa"])
    prototipo.verificar_progresso()
    print("-" * 40)

# Finalizando
print("\n" + "=" * 60)
prototipo.finalizar()

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- O desenvolvimento é um processo.")
print("- Você vai encontrar BUGS. Isso é normal.")
print("- Você vai ter que ITERAR. Isso é esperado.")
print("- O importante é NÃO PARAR.")
print("- Feito é melhor que perfeito.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Comece a desenvolver seu protótipo.
# 2. Documente cada etapa do processo.
# 3. Quando encontrar um bug, anote-o e corrija-o.
# 4. Lembre-se: o processo é tão importante quanto o resultado.
# ============================================================

# ============================================================
# SIMULADOR DE TESTES E REFINAMENTO
# ============================================================
#
# Este código simula o processo de testes, identificação de
# bugs e refinamento de um protótipo.
#
# O objetivo: mostrar que todo projeto passa por iterações
# e que o refinamento é parte do processo.
# ============================================================

import random
import time

# ============================================================
# 1. SIMULADOR DE TESTES
# ============================================================
class Testador:
    """
    Simula o processo de testes de um protótipo.
    """
    def __init__(self, prototipo):
        self.prototipo = prototipo
        self.resultados = []
        self.bugs_encontrados = []
        self.melhorias_sugeridas = []

    def testar_funcionalidade(self):
        """
        Testa se o protótipo faz o que deveria fazer.
        """
        print("\n🔧 TESTE DE FUNCIONALIDADE")
        print("-" * 40)
        print("Verificando se o protótipo funciona como esperado...")
        # Simula a execução de testes
        testes = [
            "Inicialização do sistema",
            "Execução da função principal",
            "Resposta a entradas do usuário",
            "Processamento de dados",
            "Geração de saída"
        ]
        falhas = 0
        for teste in testes:
            # 80% de chance de passar
            if random.random() < 0.8:
                print(f" ✅ {teste}: OK")
            else:
                print(f" ❌ {teste}: FALHOU")
                falhas += 1
                bug = f"Falha em {teste}"
                self.bugs_encontrados.append(bug)
        if falhas == 0:
            print("\n✅ Todos os testes de funcionalidade passaram!")
        else:
            print(f"\n⚠️ {falhas} teste(s) falharam. Bugs identificados.")
        return falhas == 0

    def testar_usabilidade(self):
        """
        Testa se o protótipo é fácil de usar.
        """
        print("\n👤 TESTE DE USABILIDADE")
        print("-" * 40)
        print("Verificando se o protótipo é intuitivo e fácil de usar...")
        aspectos = [
            "Interface clara e organizada",
            "Instruções compreensíveis",
            "Navegação intuitiva",
            "Feedback ao usuário",
            "Tempo de resposta adequado"
        ]
        problemas = 0
        for aspecto in aspectos:
            # 75% de chance de estar bom
            if random.random() < 0.75:
                print(f" ✅ {aspecto}: OK")
            else:
                print(f" ⚠️ {aspecto}: PODE MELHORAR")
                problemas += 1
                melhoria = f"Melhorar {aspecto.lower()}"
                self.melhorias_sugeridas.append(melhoria)
        if problemas == 0:
            print("\n✅ Usabilidade excelente!")
        else:
            print(f"\n💡 {problemas} aspecto(s) podem ser melhorados.")
        return problemas == 0

    def testar_acessibilidade(self):
        """
        Testa se o protótipo é acessível.
        """
        print("\n♿ TESTE DE ACESSIBILIDADE")
        print("-" * 40)
        print("Verificando se o protótipo é acessível a todos...")
        criterios = [
            "Suporte a leitores de tela",
            "Contraste adequado",
            "Fontes legíveis",
            "Navegação por teclado",
            "Descrições de imagens"
        ]
        problemas = 0
        for criterio in criterios:
            # 70% de chance de estar OK
            if random.random() < 0.7:
                print(f" ✅ {criterio}: OK")
            else:
                print(f" ⚠️ {criterio}: PODE MELHORAR")
                problemas += 1
                melhoria = f"Melhorar {criterio.lower()}"
                self.melhorias_sugeridas.append(melhoria)
        if problemas == 0:
            print("\n✅ Acessibilidade excelente!")
        else:
            print(f"\n💡 {problemas} aspecto(s) de acessibilidade podem ser melhorados.")
        return problemas == 0

    def executar_testes(self):
        """
        Executa todos os testes.
        """
        print("\n" + "=" * 60)
        print("🧪 INICIANDO BATERIA DE TESTES")
        print("=" * 60)
        resultados = {
            "funcionalidade": self.testar_funcionalidade(),
            "usabilidade": self.testar_usabilidade(),
            "acessibilidade": self.testar_acessibilidade()
        }
        print("\n" + "=" * 60)
        print("📊 RESUMO DOS TESTES")
        print("=" * 60)
        for teste, passou in resultados.items():
            status = "✅ PASSou" if passou else "❌ FALHOU"
            print(f" {teste.capitalize()}: {status}")
        if self.bugs_encontrados:
            print(f"\n🐛 Bugs encontrados: {len(self.bugs_encontrados)}")
            for bug in self.bugs_encontrados:
                print(f" - {bug}")
        if self.melhorias_sugeridas:
            print(f"\n💡 Melhorias sugeridas: {len(self.melhorias_sugeridas)}")
            for melhoria in self.melhorias_sugeridas:
                print(f" - {melhoria}")
        return resultados

# ============================================================
# 2. SIMULADOR DE REFINAMENTO
# ============================================================
class Refinador:
    """
    Simula o processo de refinamento do protótipo.
    """
    def __init__(self, prototipo, testador):
        self.prototipo = prototipo
        self.testador = testador
        self.iteracoes = 0

    def refinar(self):
        """
        Refina o protótipo com base nos resultados dos testes.
        """
        self.iteracoes += 1
        print(f"\n🔨 ITERAÇÃO DE REFINAMENTO {self.iteracoes}")
        print("=" * 60)

        # Corrigir bugs
        if self.testador.bugs_encontrados:
            print("\n🐛 CORRIGINDO BUGS...")
            for bug in self.testador.bugs_encontrados:
                print(f" 🔧 Corrigindo: {bug}")
                time.sleep(0.3)
                print(f" ✅ Bug corrigido!")
            self.testador.bugs_encontrados = []

        # Implementar melhorias
        if self.testador.melhorias_sugeridas:
            print("\n💡 IMPLEMENTANDO MELHORIAS...")
            for melhoria in self.testador.melhorias_sugeridas:
                print(f" 🚀 Implementando: {melhoria}")
                time.sleep(0.3)
                print(f" ✅ Melhoria implementada!")
            self.testador.melhorias_sugeridas = []

        print("\n✅ Refinamento concluído!")

        # Verificar se o protótipo está pronto
        if not self.testador.bugs_encontrados and not self.testador.melhorias_sugeridas:
            print("\n🎉 PROTÓTIPO PRONTO PARA O PITCH!")
            return True
        else:
            print("\n⚠️ Ainda há trabalho a fazer. Continue refinando!")
            return False

# ============================================================
# 3. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🧪 SIMULADOR DE TESTES E REFINAMENTO")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO do processo de")
print(" testes e refinamento de um protótipo.")
print(" Na vida real, esse processo é CÍCLICO e CONTÍNUO.")
print("=" * 60)

# Criando um protótipo simples
class PrototipoSimples:
    def __init__(self, nome):
        self.nome = nome
        self.versao = "1.0"

prototipo = PrototipoSimples("App de Conscientização Digital")

# Criando o testador
testador = Testador(prototipo)

# Executando os testes
testador.executar_testes()

# Refinando
print("\n" + "=" * 60)
print("🔨 INICIANDO PROCESSO DE REFINAMENTO")
print("=" * 60)
refinador = Refinador(prototipo, testador)

# Ciclo de refinamento
pronto = False
while not pronto:
    pronto = refinador.refinar()
    if not pronto:
        # Se ainda há bugs, testar novamente
        print("\n🔄 Executando novos testes...")
        testador.executar_testes()

print("\n" + "=" * 60)
print("🎉 PROTÓTIPO PRONTO PARA O PITCH!")
print("=" * 60)
print(f"\n📱 {prototipo.nome} - Versão {prototipo.versao}")
print(" Status: ✅ Pronto para apresentação")

print("\n" + "=" * 60)
print("💡 REFLEXÃO:")
print("- Testar é parte do processo. Não pule essa etapa.")
print("- Bugs não são fracasso são OPORTUNIDADES de aprendizado.")
print("- Refinar é ITERAR. E iterar é MELHORAR.")
print("- O projeto nunca fica pronto. Mas isso não é desculpa")
print(" para não lançar. Feito é melhor que perfeito.")
print("=" * 60)

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Teste seu protótipo com colegas de outros grupos.
# 2. Anote o feedback e implemente melhorias.
# 3. Prepare seu pitch de 3 minutos.
# 4. Lembre-se: o importante é comunicar sua ideia com clareza.
# ============================================================

# ============================================================
# SIMULADOR DE PITCH A GRANDE ESTREIA
# ============================================================
#
# Este código simula uma apresentação de pitch no formato
# Shark Tank / Pitch Night.
#
# O objetivo: mostrar como estruturar uma apresentação
# convincente e impactante.
# ============================================================

import time

# ============================================================
# 1. ESTRUTURA DO PITCH
# ============================================================
class Pitch:
    """
    Estrutura uma apresentação de pitch de 3 minutos.
    """
    def __init__(self, nome_projeto, problema, solucao, publico_alvo, impacto):
        self.nome_projeto = nome_projeto
        self.problema = problema
        self.solucao = solucao
        self.publico_alvo = publico_alvo
        self.impacto = impacto
        self.segmentos = []
        self._construir_pitch()

    def _construir_pitch(self):
        """Constrói os segmentos do pitch."""
        self.segmentos = [
            {
                "nome": "Abertura Impactante",
                "duracao": 20,  # segundos
                "conteudo": f"🚀 Olá! Somos o grupo e hoje vamos apresentar o {self.nome_projeto}."
            },
            {
                "nome": "O Problema",
                "duracao": 40,
                "conteudo": f"📌 O problema que identificamos: {self.problema}. Isso afeta {self.publico_alvo} e tem impactos reais."
            },
            {
                "nome": "A Solução",
                "duracao": 50,
                "conteudo": f"💡 Nossa solução: {self.solucao}. Ela funciona porque..."
            },
            {
                "nome": "Demonstração",
                "duracao": 40,
                "conteudo": "🎬 Agora, vamos demonstrar o protótipo em ação!"
            },
            {
                "nome": "Impacto",
                "duracao": 30,
                "conteudo": f"📊 O impacto esperado: {self.impacto}. E aqui estão os dados que comprovam..."
            },
            {
                "nome": "Fechamento",
                "duracao": 20,
                "conteudo": "🎯 Por que vocês deveriam acreditar nisso? Porque nós acreditamos. E porque isso importa."
            }
        ]

    def apresentar(self):
        """Simula a apresentação do pitch."""
        print("=" * 60)
        print(f"🎤 PITCH: {self.nome_projeto}")
        print("=" * 60)
        print("\n⏱️ Tempo total: 3 minutos (180 segundos)")
        print("\n" + "-" * 60)
        total_tempo = 0
        for segmento in self.segmentos:
            print(f"\n📌 {segmento['nome']} ({segmento['duracao']}s)")
            print(f"   {segmento['conteudo']}")
            total_tempo += segmento['duracao']
            time.sleep(0.2)  # simula o tempo de apresentação
        print("\n" + "-" * 60)
        print(f"\n✅ Pitch concluído! Tempo total: {total_tempo}s")
        print("\n🤝 Agora, perguntas da banca!")

# ============================================================
# 2. SIMULAÇÃO DE BANCA (PERGUNTAS E RESPOSTAS)
# ============================================================
class Banca:
    """
    Simula uma banca avaliadora que faz perguntas sobre o projeto.
    """
    def __init__(self):
        self.perguntas = [
            {
                "pergunta": "Qual foi o maior desafio que vocês enfrentaram durante o desenvolvimento?",
                "dica": "Seja honesto. Mostre que aprenderam com os desafios."
            },
            {
                "pergunta": "Como vocês sabem que essa solução realmente funciona?",
                "dica": "Mostre evidências: testes, feedback de usuários, dados."
            },
            {
                "pergunta": "O que vocês fariam diferente se tivessem mais tempo?",
                "dica": "Mostre que vocês pensam no futuro e na melhoria contínua."
            },
            {
                "pergunta": "Qual é o próximo passo? O que vem depois do protótipo?",
                "dica": "Mostre visão de futuro. O projeto não termina aqui."
            },
            {
                "pergunta": "Por que vocês escolheram esse problema?",
                "dica": "Mostre que o problema é relevante e pessoal para vocês."
            }
        ]

    def fazer_perguntas(self):
        """Simula a sessão de perguntas e respostas."""
        print("\n" + "=" * 60)
        print("❓ SESSÃO DE PERGUNTAS E RESPOSTAS")
        print("=" * 60)
        print("\nA banca vai fazer algumas perguntas. Respondam com confiança!")
        for i, item in enumerate(self.perguntas, 1):
            print(f"\n📌 PERGUNTA {i}: {item['pergunta']}")
            print(f"   💡 Dica: {item['dica']}")
            print("   🤔 (Pausa para resposta do grupo)")
            time.sleep(0.5)
        print("\n" + "=" * 60)
        print("✅ Sessão de perguntas concluída!")
        print(" Parabéns, grupo! Vocês mandaram bem!")

# ============================================================
# 3. AUTOAVALIAÇÃO
# ============================================================
class Autoavaliacao:
    """
    Simula o processo de autoavaliação após a apresentação.
    """
    def __init__(self):
        self.perguntas = [
            "O que eu aprendi com este projeto?",
            "O que foi mais difícil?",
            "O que eu faria diferente?",
            "O que eu mais curti no processo?",
            "Como eu me sinto agora?"
        ]

    def refletir(self):
        """Guia a reflexão individual."""
        print("\n" + "=" * 60)
        print("📝 AUTOAVALIAÇÃO")
        print("=" * 60)
        print("\nReserve um momento para refletir sobre sua jornada:")
        for pergunta in self.perguntas:
            print(f"\n❓ {pergunta}")
            print("   (Escreva sua resposta em seu caderno/diário)")
        print("\n" + "=" * 60)
        print("💡 LEMBRE-SE:")
        print(" O projeto é importante, mas o que você")
        print(" se tornou para construí-lo é ainda mais.")
        print("=" * 60)

# ============================================================
# 4. SIMULAÇÃO
# ============================================================
print("=" * 60)
print("🎬 SIMULADOR DE PITCH A GRANDE ESTREIA")
print("=" * 60)
print("\n⚠️ ATENÇÃO: Isso é uma SIMULAÇÃO de uma")
print(" apresentação de pitch.")
print(" Na vida real, vai ser ainda mais emocionante!")
print("=" * 60)

# Criando o pitch
pitch = Pitch(
    nome_projeto="App: 'Tempo de Tela Consciente'",
    problema="Jovens passam em média 4+ horas por dia em redes sociais, com impactos negativos na saúde mental.",
    solucao="Um app que monitora o uso do celular e envia alertas personalizados para pausas conscientes.",
    publico_alvo="Adolescentes e jovens adultos (15-25 anos)",
    impacto="Redução de 30% no tempo de tela e melhora na qualidade do sono."
)

# Apresentando o pitch
pitch.apresentar()

# Sessão de perguntas
banca = Banca()
banca.fazer_perguntas()

# Autoavaliação
autoavaliacao = Autoavaliacao()
autoavaliacao.refletir()

print("\n" + "=" * 60)
print("🎉 PARABÉNS! VOCÊ CONCLUIU O PITCH!")
print("=" * 60)
print("\nA jornada foi longa, o código foi escrito,")
print("os bugs foram exterminados.")
print("Agora, o que importa não é o site que vocês construíram")
print("--- é o que vocês se tornaram para construí-lo.")
print("\n🚀 Vocês são incríveis. Continuem assim.")

# ============================================================
# DESAFIO PARA OS ALUNOS:
# 1. Apresente seu projeto para a turma.
# 2. Responda às perguntas da banca com confiança.
# 3. Faça sua autoavaliação.
# 4. Comemore! Você merece.
# ============================================================