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 AdminPanel:
    def __init__(self, db: DatabaseManager):
        self.db = db

    def process_command(self, message: str, user_id: str) -> str:
        if not self.db.is_admin(user_id):
            return "Desculpe, apenas administradores têm acesso a este comando."

        command = message.split(maxsplit=1)[1].strip() if len(message.split()) > 1 else ""

        if command.startswith("adicionar_questao"):
            try:
                questao_data = json.loads(command.split(maxsplit=1)[1])
                self.db.add_question(questao_data)
                return "Questão adicionada com sucesso!"
            except (json.JSONDecodeError, KeyError, IndexError):
                return "Erro ao adicionar questão. Verifique o formato dos dados."
        elif command.startswith("atualizar_questao"):
            try:
                questao_id, questao_data = command.split(maxsplit=2)[1:]
                questao_data = json.loads(questao_data)
                self.db.update_question(int(questao_id), questao_data)
                return "Questão atualizada com sucesso!"
            except (json.JSONDecodeError, KeyError, IndexError, ValueError):
                return "Erro ao atualizar questão. Verifique o formato dos dados."
        elif command.startswith("remover_questao"):
            try:
                questao_id = int(command.split(maxsplit=1)[1])
                self.db.remove_question(questao_id)
                return "Questão removida com sucesso!"
            except (IndexError, ValueError):
                return "Erro ao remover questão. Verifique o ID fornecido."
        else:
            return "Comando inválido. Comandos disponíveis: adicionar_questao, atualizar_questao, remover_questao."

class CRMJABot:
    def __init__(self):
        try:
            self.db = DatabaseManager()
        except Exception as e:
            print(f"Erro ao inicializar o DatabaseManager: {e}")
            return

        try:
            self.performance, self.material_generator, self.tracker = initialize_performance_system(
                self.db.get_connection()
            )
        except Exception as e:
            print(f"Erro ao inicializar o sistema de desempenho: {e}")
            return
        
        self.planner = StudyPlanGenerator(self.db)
        self.coach = MotivationalCoach()
        self.admin_panel = AdminPanel(self.db)
        self.user_info = {}
        
        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 de perguntas e respostas: {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 ao carregar as questões do arquivo JSON: {str(e)}")

    def process_message(self, message, user_id, history):
        if user_id not in self.user_info:
            self.user_info[user_id] = {'name': None, 'email': None}
            
        if not self.user_info[user_id]['name']:
            self.user_info[user_id]['name'] = message
            return f"Prazer em conhecê-lo(a), {message}! Por favor, me informe também seu email para que eu possa personalizar melhor sua experiência."
        elif not self.user_info[user_id]['email']:
            self.user_info[user_id]['email'] = message  
            self.db.add_user(user_id, self.user_info[user_id]['name'], self.user_info[user_id]['email'])
            return f"Obrigado, {self.user_info[user_id]['name']}! Agora estou pronto para ajudá-lo(a) com sua preparação para o Revalida. O que você gostaria de fazer? Digite /help para ver as opções."
                
        if message.strip() == "":
            return ""
        
        if message.startswith("/"):
            command = message.split()[0]
            if command == "/start":
                return f"Bem-vindo de volta, {self.user_info[user_id]['name']}! Como posso ajudar hoje?"
            elif command == "/help":
                return """Comandos disponíveis:
/start - Inicia o bot
/help - Mostra os comandos disponíveis 
/progresso - Verifica seu progresso
/resumo - Mostra um resumo do seu desempenho
/estudo - Registra uma sessão de estudo
/lembretes - Configura lembretes de estudo
/admin - Acessa o painel de administração (apenas para administradores)"""
            elif command == "/progresso":
                return self.check_progress(user_id)
            elif command == "/resumo":
                return self.get_summary(user_id)  
            elif command == "/estudo":
                return self.study_mode(message, user_id)
            elif command == "/lembretes":
                return self.set_reminders(message, user_id)
            elif command == "/admin":  
                return self.admin_panel.process_command(message, user_id)
            else:
                return "Comando inválido. Digite /help para ver os comandos disponíveis."
        else:
            return self.generate_response(message, user_id, history)

    def generate_response(self, message, user_id, history):
        if self.qa_pipeline:
            try:
                question = message
                context = " ".join([msg[1] for msg in history[-5:]])
                answer = self.qa_pipeline(question=question, context=context)
                return answer['answer']
            except Exception as e:
                print(f"Erro ao gerar resposta: {e}")
                return "Desculpe, não consegui entender sua pergunta. Poderia reformular?"
        else:
            return "Desculpe, ainda estou aprendendo a responder perguntas gerais. Por enquanto, posso ajudar com comandos específicos. Digite /help para ver o que sei fazer!"

    def check_progress(self, user_id):
        try:
            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 = pd.Series(data['scores']).mean() if data['scores'] else 0
                response += f"\n  ▪ {topic}: {avg_score:.1f}% ({data['total_hours']}h)"

            weak_topics = [topic for topic, data in metrics['topic_metrics'].items() 
                         if pd.Series(data['scores']).mean() < 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]:
                        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, user_id):
        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])

            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()

            metrics = self.performance.get_performance_metrics(user_id) 
            streak_info = self.tracker.calculate_study_streak(user_id)

            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, user_id):
        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 = pd.Series(data['scores']).mean() 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 set_reminders(self, message, user_id):
        parts = message.split()
        if len(parts) < 3:
            return """📅 Para configurar lembretes de estudo:
            
Formato: /lembretes hora frequência
Exemplo: /lembretes 20:00 diariamente"""

        reminder_time = parts[1]
        frequency = parts[2]

        self.db.set_reminder(user_id, reminder_time, frequency)

        return f"✅ Lembrete de estudo configurado com sucesso para as {reminder_time}, {frequency}!"

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):
            if message.strip() == "":
                return "", history
            
            bot_message = bot.process_message(message, user_id.value or "default_user", history)
            history.append((message, bot_message))
            return "", history