app.py

import gradio as gr
from datetime import datetime
from sentence_transformers import SentenceTransformer
import numpy as np
from typing import Dict, List, Tuple
import matplotlib.pyplot as plt
from wordcloud import WordCloud
import seaborn as sns
import pandas as pd
from collections import Counter

# Load embeddings model
model = SentenceTransformer('all-MiniLM-L6-v2')

# Define questions with categories and context
PERGUNTAS = [
    {
        "categoria": "autoconhecimento",
        "pergunta": "Qual foi seu maior desafio como líder e como você o superou?",
        "contexto": "desafios liderança superação aprendizado desenvolvimento",
    },
    {
        "categoria": "comunicacao",
        "pergunta": "Como você adapta seu estilo de comunicação para diferentes membros da equipe?",
        "contexto": "comunicação adaptação equipe feedback clareza",
    },
    {
        "categoria": "decisao",
        "pergunta": "Descreva uma decisão difícil recente e como você a tomou.",
        "contexto": "decisão análise processo resultado impacto",
    },
    {
        "categoria": "autoconhecimento",
        "pergunta": "Como você identificou e desenvolveu seus pontos fortes como líder?",
        "contexto": "fortalezas desenvolvimento crescimento reconhecimento",
    },
    {
        "categoria": "comunicacao",
        "pergunta": "Descreva uma situação em que você precisou dar feedback difícil. Como conduziu?",
        "contexto": "feedback difícil comunicação empatia resolução",
    }
]

# Enhanced response system with more context and situation-specific feedback
RESPOSTAS_COACH = {
    "autoconhecimento": {
        "positive": [
            {
                "context": "superacao_clara",
                "response": "Sua capacidade de superar esse desafio demonstra resiliência. Especialmente interessante foi como você {specific_action}. Como você pode usar essa experiência para orientar outros líderes em situações similares?",
                "keywords": ["superei", "consegui", "aprendi", "mudei", "cresci"]
            },
            {
                "context": "aprendizado_continuo",
                "response": "Sua jornada de autodesenvolvimento é notável. O fato de você {specific_action} mostra maturidade. Que outros aspectos de liderança essa experiência te motivou a explorar?",
                "keywords": ["desenvolvimento", "estudo", "aprendo", "busco", "evoluo"]
            }
        ],
        "neutral": [
            {
                "context": "em_processo",
                "response": "Você está no caminho certo ao identificar esse desafio. Considerando que você {specific_action}, que recursos ou apoio adicional seriam úteis nesse momento?",
                "keywords": ["tentando", "buscando", "desenvolvendo", "praticando"]
            }
        ],
        "improvement": [
            {
                "context": "dificuldade_identificada",
                "response": "É importante reconhecer áreas de desenvolvimento. Sua menção sobre {specific_action} sugere autoconsciência. Vamos explorar estratégias específicas para fortalecer esse aspecto?",
                "keywords": ["difícil", "complicado", "desafiador", "preciso melhorar"]
            }
        ]
    },
    "comunicacao": {
        "positive": [
            {
                "context": "adaptacao_efetiva",
                "response": "Sua abordagem adaptativa é exemplar. O exemplo de como você {specific_action} demonstra sensibilidade às diferentes necessidades. Como você avalia a efetividade dessas adaptações?",
                "keywords": ["adapto", "personalizo", "ajusto", "observo"]
            }
        ],
        "neutral": [
            {
                "context": "desenvolvendo_estilo",
                "response": "Você está desenvolvendo um repertório interessante de estilos de comunicação. Sua estratégia de {specific_action} tem potencial. Que outros métodos você gostaria de experimentar?",
                "keywords": ["testando", "experimentando", "tentando diferentes"]
            }
        ],
        "improvement": [
            {
                "context": "desafios_comunicacao",
                "response": "Reconhecer desafios na comunicação é o primeiro passo. Considerando sua experiência com {specific_action}, que aspectos específicos você gostaria de desenvolver primeiro?",
                "keywords": ["difícil comunicar", "não consegui", "preciso melhorar"]
            }
        ]
    },
    "decisao": {
        "positive": [
            {
                "context": "processo_estruturado",
                "response": "Seu processo decisório é bem estruturado. A forma como você {specific_action} demonstra pensamento sistêmico. Como você poderia documentar essas práticas para futuras referências?",
                "keywords": ["analisei", "considerei", "planejei", "estruturei"]
            }
        ],
        "neutral": [
            {
                "context": "balanceando_fatores",
                "response": "Você está equilibrando diferentes fatores em suas decisões. Sua menção sobre {specific_action} mostra consciência. Que frameworks de decisão você conhece que poderiam complementar sua abordagem?",
                "keywords": ["pesando", "considerando", "avaliando"]
            }
        ],
        "improvement": [
            {
                "context": "decisao_desafiadora",
                "response": "Decisões complexas exigem coragem. Sua experiência com {specific_action} oferece aprendizados valiosos. Que apoio ou recursos adicionais teriam sido úteis nesse momento?",
                "keywords": ["hesitei", "demorei", "incerto"]
            }
        ]
    }
}

class EnhancedCoach:
    def __init__(self):
        self.pergunta_atual = 0
        self.inicio = datetime.now()
        self.historico_respostas = []
        self.tempo_ultima_resposta = datetime.now()
        
    def analisar_sentimento(self, texto: str) -> str:
        """Analisa o sentimento geral da resposta."""
        positive_words = ["consegui", "superei", "aprendi", "melhorei", "efetivo"]
        negative_words = ["difícil", "desafiador", "complicado", "problema", "falha"]
        
        texto_lower = texto.lower()
        positive_count = sum(1 for word in positive_words if word in texto_lower)
        negative_count = sum(1 for word in negative_words if word in texto_lower)
        
        if positive_count > negative_count:
            return "positive"
        elif negative_count > positive_count:
            return "improvement"
        return "neutral"

    def extrair_acao_especifica(self, texto: str) -> str:
        """Extrai uma ação específica mencionada na resposta."""
        sentences = texto.split('.')
        for sentence in sentences:
            if any(action in sentence.lower() for action in ["eu", "minha", "realizei", "fiz"]):
                return sentence.strip()
        return texto.split('.')[0].strip()

    def encontrar_melhor_resposta(self, texto_usuario: str, categoria: str) -> str:
        sentimento = self.analisar_sentimento(texto_usuario)
        acao_especifica = self.extrair_acao_especifica(texto_usuario)
        
        respostas_categoria = RESPOSTAS_COACH[categoria][sentimento]
        user_embedding = model.encode(texto_usuario)
        
        melhor_resposta = None
        maior_similaridade = -1
        
        for template in respostas_categoria:
            context_embedding = model.encode(template["context"])
            similaridade = np.dot(user_embedding, context_embedding)
            
            if similaridade > maior_similaridade:
                maior_similaridade = similaridade
                melhor_resposta = template["response"]
        
        return melhor_resposta.format(specific_action=acao_especifica.lower())

    def gerar_resposta(self, texto_usuario: str) -> str:
        self.tempo_ultima_resposta = datetime.now()
        pergunta_atual = PERGUNTAS[self.pergunta_atual]
        self.historico_respostas.append(texto_usuario)
        
        feedback = self.encontrar_melhor_resposta(
            texto_usuario, 
            pergunta_atual["categoria"]
        )
        
        # Analisa padrões nas respostas anteriores
        padrao_identificado = ""
        if len(self.historico_respostas) > 1:
            sentimento_atual = self.analisar_sentimento(texto_usuario)
            sentimento_anterior = self.analisar_sentimento(self.historico_respostas[-2])
            
            if sentimento_atual == sentimento_anterior == "positive":
                padrao_identificado = "\n\n💡 Observo um padrão consistente de confiança em suas respostas. Continue desenvolvendo esses pontos fortes!"
            elif sentimento_atual == sentimento_anterior == "improvement":
                padrao_identificado = "\n\n💡 Percebo que você está identificando áreas de desenvolvimento. Vamos focar em estratégias práticas para esses desafios."
        
        resposta = f"""### Feedback Personalizado 💭

{feedback}{padrao_identificado}

#### Pontos para Aprofundamento:
1. Como essa experiência se conecta com seus valores de liderança?
2. Que recursos específicos você identificou como necessários?
3. Qual seria o próximo marco de desenvolvimento nessa área?"""
        
        self.pergunta_atual += 1
        if self.pergunta_atual < len(PERGUNTAS):
            proxima = PERGUNTAS[self.pergunta_atual]
            resposta += f"""

### Próxima Reflexão: {proxima['categoria'].title()} 🎯

{proxima['pergunta']}

Tome um momento para refletir e conectar com suas experiências..."""
        else:
            tempo = (datetime.now() - self.inicio).seconds // 60
            resposta += self.gerar_sumario_final(tempo)
        
        return resposta
    
    def get_tempo_ultima_resposta(self) -> str:
        """Calcula o tempo desde a última resposta."""
        delta = datetime.now() - self.tempo_ultima_resposta
        minutos = delta.seconds // 60
        segundos = delta.seconds % 60
        return f"{minutos}:{segundos:02d}"

    def gerar_sumario_final(self, tempo: int) -> str:
        # Analisa padrões gerais nas respostas
        sentimentos = [self.analisar_sentimento(resp) for resp in self.historico_respostas]
        predominante = max(set(sentimentos), key=sentimentos.count)
        
        if predominante == "positive":
            perfil = "Você demonstra forte autoconhecimento e confiança em sua liderança."
        elif predominante == "improvement":
            perfil = "Você demonstra excelente capacidade de identificar oportunidades de desenvolvimento."
        else:
            perfil = "Você demonstra uma abordagem equilibrada entre conquistas e desafios."
        
        return f"""

### 🎉 Jornada de Desenvolvimento Concluída!

⏱️ Tempo de reflexão: {tempo} minutos
📝 Temas explorados: {len(PERGUNTAS)}

#### Perfil de Liderança Observado:
{perfil}

#### Recomendações Personalizadas:
1. Implemente uma ação específica mencionada em suas reflexões esta semana
2. Mantenha um diário de liderança focado nos temas discutidos
3. Estabeleça checkpoints mensais para revisar seu progresso

Deseja iniciar uma nova jornada de desenvolvimento com outros temas?"""

    def primeira_pergunta(self):
        return f"""### 👋 Bem-vindo à sua Jornada de Desenvolvimento!

Vamos explorar aspectos importantes da sua liderança através de reflexões guiadas.

{PERGUNTAS[0]['pergunta']}

Tome um momento para conectar com suas experiências e compartilhe sua perspectiva..."""

def analyze_sentiment_trend(respostas: List[str]) -> plt.Figure:
    """Generate sentiment analysis plot"""
    coach = EnhancedCoach()
    sentimentos = [coach.analisar_sentimento(resp) for resp in respostas]
    
    # Convert sentiments to numeric values
    valor_sentimento = {
        'positive': 1,
        'neutral': 0,
        'improvement': -1
    }
    valores = [valor_sentimento[s] for s in sentimentos]
    
    # Create the plot
    fig, ax = plt.subplots(figsize=(8, 4))
    sns.lineplot(data=valores, marker='o', ax=ax)
    
    ax.set_title('Tendência de Sentimento nas Respostas')
    ax.set_xlabel('Número da Resposta')
    ax.set_ylabel('Sentimento')
    ax.set_ylim(-1.5, 1.5)
    ax.grid(True)
    
    # Add horizontal lines for reference
    ax.axhline(y=0, color='gray', linestyle='--', alpha=0.5)
    
    return fig

def generate_word_cloud(respostas: List[str]) -> plt.Figure:
    """Generate word cloud visualization"""
    # Combine all responses
    texto_completo = ' '.join(respostas)
    
    # Create word cloud
    wordcloud = WordCloud(
        width=800,
        height=400,
        background_color='white',
        colormap='viridis',
        max_words=100
    ).generate(texto_completo)
    
    # Create the plot
    fig, ax = plt.subplots(figsize=(10, 5))
    ax.imshow(wordcloud, interpolation='bilinear')
    ax.axis('off')
    ax.set_title('Nuvem de Palavras das Reflexões')
    
    return fig

def analyze_themes(respostas: List[str]) -> Tuple[str, str]:
    """Analyze strong themes and development areas"""
    coach = EnhancedCoach()
    temas_fortes = []
    areas_desenvolvimento = []
    
    for resp in respostas:
        sentimento = coach.analisar_sentimento(resp)
        if sentimento == "positive":
            temas_fortes.append("- " + coach.extrair_acao_especifica(resp))
        elif sentimento == "improvement":
            areas_desenvolvimento.append("- " + coach.extrair_acao_especifica(resp))
    
    temas_fortes_str = "\n".join(temas_fortes[:3]) if temas_fortes else "Análise em andamento..."
    areas_desenvolvimento_str = "\n".join(areas_desenvolvimento[:3]) if areas_desenvolvimento else "Análise em andamento..."
    
    return temas_fortes_str, areas_desenvolvimento_str

def criar_interface():
    coach = EnhancedCoach()
    
    with gr.Blocks(title="Coach de Liderança", theme=gr.themes.Soft()) as app:
        with gr.Row():
            with gr.Column(scale=2):
                gr.Markdown("""
                # 🚀 Coach de Liderança
                
                Desenvolva sua liderança através de reflexão guiada e feedback personalizado.
                """)
            
            with gr.Column(scale=1):
                timer = gr.Number(value=0, label="⏱️ Tempo de Reflexão (minutos)", interactive=False)
                progress = gr.Slider(
                    value=0,
                    minimum=0,
                    maximum=len(PERGUNTAS),
                    step=1,
                    label="📊 Progresso",
                    interactive=False
                )
        
        with gr.Tabs() as tabs:
            with gr.Tab("💭 Sessão Atual"):
                chat = gr.Chatbot(
                    value=[[None, coach.primeira_pergunta()]],
                    height=500,
                    show_label=False
                )
                
                with gr.Row():
                    with gr.Column(scale=4):
                        txt = gr.Textbox(
                            placeholder="Compartilhe sua reflexão aqui...",
                            lines=4,
                            label="Sua Resposta"
                        )
                    
                    with gr.Column(scale=1, min_width=100):
                        with gr.Row():
                            btn = gr.Button("Enviar", variant="primary")
                            clear = gr.Button("Limpar")
                
                with gr.Row():
                    tema_atual = gr.Textbox(
                        value="Autoconhecimento",
                        label="🎯 Tema Atual",
                        interactive=False
                    )
                    tempo_resposta = gr.Textbox(
                        value="0:00",
                        label="⏱️ Tempo nesta resposta",
                        interactive=False
                    )
            
            with gr.Tab("📊 Insights"):
                with gr.Row():
                    with gr.Column():
                        sentiment_chart = gr.Plot(label="Análise de Sentimento")
                    with gr.Column():
                        word_cloud = gr.Plot(label="Nuvem de Palavras")
                
                with gr.Row():
                    temas_fortes = gr.Textbox(
                        label="💪 Temas com Mais Confiança",
                        interactive=False,
                        lines=3
                    )
                    areas_desenvolvimento = gr.Textbox(
                        label="🎯 Áreas para Desenvolvimento",
                        interactive=False,
                        lines=3
                    )
            
            with gr.Tab("📝 Notas & Recursos"):
                with gr.Row():
                    notas = gr.Textbox(
                        placeholder="Faça anotações durante sua jornada...",
                        label="📝 Minhas Notas",
                        lines=5
                    )
                    
                with gr.Row():
                    with gr.Accordion("📚 Recursos por Tema", open=False):
                        gr.Markdown("""
                        ### 🎯 Autoconhecimento
                        - [Artigo] Desenvolvendo Autoconsciência na Liderança
                        - [Exercício] Reflexão sobre Valores e Propósito
                        - [Ferramenta] Template de Diário de Liderança
                        
                        ### 💬 Comunicação
                        - [Guia] Comunicação Assertiva na Liderança
                        - [Checklist] Preparação para Feedbacks Difíceis
                        - [Framework] Estrutura de Comunicação Situacional
                        
                        ### 🤔 Tomada de Decisão
                        - [Modelo] Framework para Decisões Complexas
                        - [Exercício] Análise de Decisões Passadas
                        - [Template] Documentação de Decisões Importantes
                        """)
                
                with gr.Row():
                    with gr.Accordion("🔄 Práticas Recomendadas", open=False):
                        gr.Markdown("""
                        ### 📝 Dicas para Reflexão Efetiva
                        1. Reserve um momento tranquilo para suas reflexões
                        2. Seja específico em seus exemplos
                        3. Conecte suas experiências com aprendizados
                        4. Considere diferentes perspectivas
                        5. Anote insights importantes
                        
                        ### 🎯 Como Aproveitar o Feedback
                        1. Revise os pontos destacados
                        2. Faça conexões com situações atuais
                        3. Defina ações práticas
                        4. Estabeleça prazos para implementação
                        5. Acompanhe seu progresso
                        """)
        
        def atualizar_timer():
            """Update session timer"""
            return gr.update(value=int((datetime.now() - coach.inicio).total_seconds() / 60))
        
        def atualizar_progresso():
            """Update progress bar"""
            return gr.update(value=coach.pergunta_atual)
        
        def atualizar_tema():
            """Update current theme"""
            if coach.pergunta_atual < len(PERGUNTAS):
                return PERGUNTAS[coach.pergunta_atual]["categoria"].title()
            return "Jornada Concluída"
        
        def atualizar_tempo_resposta():
            """Update response timer"""
            return coach.get_tempo_ultima_resposta()
        
        def limpar_chat():
            """Reset chat and all related components"""
            coach.__init__()  # Reset coach state
            return {
                chat: [[None, coach.primeira_pergunta()]],
                txt: "",
                progress: 0,
                tema_atual: "Autoconhecimento",
                tempo_resposta: "0:00",
                sentiment_chart: None,
                word_cloud: None,
                temas_fortes: "",
                areas_desenvolvimento: ""
            }
        
        def responder(mensagem, historico):
            """Process user response and update interface"""
            if not mensagem.strip():
                return {
                    txt: "",
                    chat: historico
                }
            
            # Generate response
            resposta = coach.gerar_resposta(mensagem)
            historico.append([mensagem, resposta])
            
            # Update visualizations
            sentiment_analysis = None
            word_cloud_plot = None
            strong_themes = ""
            development_areas = ""
            
            if len(coach.historico_respostas) > 1:
                sentiment_analysis = analyze_sentiment_trend(coach.historico_respostas)
                word_cloud_plot = generate_word_cloud(coach.historico_respostas)
                strong_themes, development_areas = analyze_themes(coach.historico_respostas)
            
            return {
                txt: "",
                chat: historico,
                timer: int((datetime.now() - coach.inicio).total_seconds() / 60),
                progress: coach.pergunta_atual,
                tema_atual: atualizar_tema(),
                tempo_resposta: "0:00",
                sentiment_chart: sentiment_analysis,
                word_cloud: word_cloud_plot,
                temas_fortes: strong_themes,
                areas_desenvolvimento: development_areas
            }
        
        # Event handlers
        txt.submit(
            responder, 
            [txt, chat], 
            [txt, chat, timer, progress, tema_atual, tempo_resposta,
             sentiment_chart, word_cloud, temas_fortes, areas_desenvolvimento]
        )
        
        btn.click(
            responder, 
            [txt, chat], 
            [txt, chat, timer, progress, tema_atual, tempo_resposta,
             sentiment_chart, word_cloud, temas_fortes, areas_desenvolvimento]
        )
        
        clear.click(
            limpar_chat,
            None,
            [chat, txt, progress, tema_atual, tempo_resposta,
             sentiment_chart, word_cloud, temas_fortes, areas_desenvolvimento]
        )
        
        # Periodic updates
        timer.update(atualizar_timer, every=60)  # Update timer every minute
        tempo_resposta.update(atualizar_tempo_resposta, every=1)  # Update response timer every second
        
    return app

if __name__ == "__main__":
    app = criar_interface()
    app.launch()