app.py

import gradio as gr
from transformers import pipeline
import json
import sqlite3
from datetime import datetime, timedelta
import pandas as pd
import random
from typing import Dict, List, Optional
from database.db_manager import DatabaseManager
from database.db_operations import adicionar_lote_questoes
from study_generators import StudyPlanGenerator
from performance_system import (
    PerformanceAnalyzer, 
    StudyMaterialGenerator, 
    ProgressTracker,
    initialize_performance_system
)

class MotivationalCoach:
    def __init__(self):
        self.frases_motivacionais = [
            "🌟 Cada hora de estudo te aproxima mais do seu objetivo!",
            "💪 Você está construindo seu futuro a cada dia!",
            "🎯 Mantenha o foco! O Revalida é só uma etapa da sua jornada de sucesso!",
            "⭐ Sua dedicação é inspiradora! Continue assim!",
            "🌈 Acredite no seu potencial! Você está no caminho certo!",
            "📚 Conhecimento é poder, e você está ficando mais forte a cada dia!",
            "🌅 Um novo dia, uma nova oportunidade de aprender!",
            "🎓 Sua aprovação no Revalida está cada vez mais próxima!"
        ]
        self.dicas_estudo = [
            "📌 Faça pequenas pausas a cada 45 minutos de estudo",
            "💡 Revise o conteúdo do dia antes de dormir",
            "🎯 Estabeleça metas diárias pequenas e alcançáveis",
            "📊 Alterne entre diferentes tópicos para manter o interesse",
            "🌟 Pratique questões antigas do Revalida regularmente",
            "💪 Mantenha uma rotina regular de estudos",
            "🧠 Use mapas mentais para conectar conceitos",
            "📝 Faça resumos ativos do conteúdo estudado"
        ]

    def get_motivational_message(self) -> str:
        return random.choice(self.frases_motivacionais)

    def get_study_tip(self) -> str:
        return random.choice(self.dicas_estudo)

class CRMJABot:
    def __init__(self):
        self.db = DatabaseManager()
        
        # Inicializa sistema de performance
        self.performance, self.material_generator, self.tracker = initialize_performance_system(
            self.db.get_connection()
        )
        
        self.planner = StudyPlanGenerator(self.db)
        self.coach = MotivationalCoach()
        
        try:
            self.qa_pipeline = pipeline(
                "question-answering",
                model="pierreguillou/bert-base-cased-squad-v1.1-portuguese",
                device=-1
            )
        except Exception as e:
            print(f"Erro ao carregar o modelo: {e}")
            self.qa_pipeline = None

        try:
            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
                questoes = json.load(f)
            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
            print("Questões adicionadas com sucesso!" if sucesso else f"Erro: {mensagem}")
        except Exception as e:
            print(f"Erro na inicialização: {str(e)}")

    def process_message(self, message, user_id, history):
    def check_progress(self, message: str, user_id: str) -> str:
        try:
            # Obtém métricas detalhadas usando o novo sistema
            metrics = self.performance.get_performance_metrics(user_id)
            streak_info = self.tracker.calculate_study_streak(user_id)
            
            response = f"""📊 Análise Detalhada do seu Progresso:
  ⭐ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
  🎯 Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
  📅 Dias de estudo: {metrics['overall_metrics']['study_days']}
  🔥 Sequência atual: {streak_info['current_streak']} dias
  🏆 Maior sequência: {streak_info['longest_streak']} dias 
  📈 Desempenho por área:"""
            
            for topic, data in metrics['topic_metrics'].items():
                avg_score = np.mean(data['scores']) if data['scores'] else 0
                response += f"\n  ▪ {topic}: {avg_score:.1f}% ({data['total_hours']}h)"

            # Adiciona recomendações baseadas no desempenho
            weak_topics = [topic for topic, data in metrics['topic_metrics'].items() 
                         if np.mean(data['scores']) < 70]
            
            if weak_topics:
                response += "\n\n📚 Áreas que precisam de mais atenção:"
                for topic in weak_topics:
                    resources = self.material_generator.get_recommended_resources(
                        topic, metrics['topic_metrics'][topic]
                    )
                    response += f"\n  ▪ {topic}:"
                    for resource in resources[:2]:  # Limita a 2 recursos por tópico
                        response += f"\n    - {resource}"

            response += f"\n\n{self.coach.get_motivational_message()}"
            
            return response
            
        except Exception as e:
            return f"Erro ao verificar progresso: {str(e)}"

    def study_mode(self, message: str, user_id: str) -> str:
        try:
            parts = message.split()
            if len(parts) < 3:
                return """📚 Para registrar seu estudo:
                
Formato: /estudo área horas
Exemplo: /estudo ClínicaMédica 2.5"""
            
            area = parts[1]
            horas = float(parts[2])
            
            # Registra a sessão
            cursor = self.db.get_connection().cursor()
            cursor.execute('''
            INSERT INTO study_progress
            (user_id, date, topic, horas_estudadas, performance_score)
            VALUES (?, ?, ?, ?, ?)
            ''', (user_id, datetime.now().date(), area, horas, 0.0))
            self.db.get_connection().commit()
            
            # Obtém métricas atualizadas
            metrics = self.performance.get_performance_metrics(user_id)
            streak_info = self.tracker.calculate_study_streak(user_id)
            
            # Gera plano personalizado para próxima sessão
            next_plan = self.material_generator.generate_daily_plan(
                user_id, horas, metrics['topic_metrics']
            )
            
            response = f"""✅ Ótimo trabalho! Registrei {horas}h de estudo em {area}

📊 Status atual:
⭐ Total de horas: {metrics['overall_metrics']['total_hours']:.1f}h
🔥 Sequência: {streak_info['current_streak']} dias
🏆 Recorde: {streak_info['longest_streak']} dias

📚 Sugestões para próxima sessão:"""

            for area, horas in next_plan['distribuicao_horas'].items():
                response += f"\n  ▪ {area}: {horas}h"
                
            response += f"\n\n{self.coach.get_motivational_message()}"
            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
            
            return response
            
        except Exception as e:
            return f"Erro ao registrar estudo: {str(e)}"

    def get_summary(self, message: str, user_id: str) -> str:
        try:
            metrics = self.performance.get_performance_metrics(user_id)
            streak_info = self.tracker.calculate_study_streak(user_id)
            
            response = f"""📊 Resumo Completo do seu Desempenho:

⏱ Métricas Gerais:
▪ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
▪ Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
▪ Dias de estudo: {metrics['overall_metrics']['study_days']}
▪ Sequência atual: {streak_info['current_streak']} dias
▪ Maior sequência: {streak_info['longest_streak']} dias

📈 Progresso por Área:"""
            
            for topic, data in metrics['topic_metrics'].items():
                avg_score = np.mean(data['scores']) if data['scores'] else 0
                last_study = data['last_study']
                response += f"\n\n📌 {topic}:"
                response += f"\n  ▪ Desempenho: {avg_score:.1f}%"
                response += f"\n  ▪ Horas dedicadas: {data['total_hours']}h"
                response += f"\n  ▪ Último estudo: {last_study}"

            response += f"\n\n{self.coach.get_motivational_message()}"
            
            return response
            
        except Exception as e:
            return f"Erro ao gerar resumo: {str(e)}"

def create_interface():
    bot = CRMJABot()
    
    with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface:
        gr.Markdown("# 🏥 crmjaBot")
        gr.Markdown("### Seu mentor personalizado para o Revalida")
        
        with gr.Row():
            with gr.Column():
                user_id = gr.Textbox(
                    label="Seu ID (email ou telefone)",
                    placeholder="Digite seu ID único..."
                )
        
        chatbot = gr.Chatbot()
        msg = gr.Textbox(
            placeholder="Digite sua mensagem ou comando aqui...",
            show_label=False
        )
        clear = gr.ClearButton([msg, chatbot])

        def respond(message, history):
            bot_message = bot.process_message(message, user_id.value or "default_user", history)
            history.append((message, bot_message))
            return "", history

        msg.submit(respond, [msg, chatbot], [msg, chatbot])

    return interface

if __name__ == "__main__":
    interface = create_interface()
    interface.launch()