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 performance_system import PerformanceAnalyzer
from simulado_system import SimuladoSystem, CasoClinicoSystem
import json
from database.db_manager import DatabaseManager
from database.db_operations import adicionar_lote_questoes

def main():
    db = DatabaseManager()
    
    # Carrega questões do arquivo JSON
    with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
        questoes = json.load(f)
    
    # Adiciona as questões ao banco
    sucesso, mensagem = adicionar_lote_questoes(db, questoes)
    
    if sucesso:
        print("Questões adicionadas com sucesso!")
    else:
        print(f"Erro: {mensagem}")

if __name__ == "__main__":
    main()
def buscar_questoes_para_simulado(db: DatabaseManager, usuario_id: str, 
                                 num_questoes: int = 10, 
                                 areas: list = None,
                                 dificuldade: str = None):
    """Busca questões para gerar simulado personalizado"""
    try:
        conn = db.get_connection()
        cursor = conn.cursor()
        
        # Busca áreas fracas do usuário
        user_profile = db.get_user_profile(usuario_id)
        weak_areas = user_profile.get('weak_areas', [])
        
        # Monta a query
        query = '''
        SELECT * FROM previous_questions 
        WHERE 1=1
        '''
        params = []
        
        if areas:
            query += ' AND area IN ({})'.format(','.join(['?']*len(areas)))
            params.extend(areas)
            
        if dificuldade:
            query += ' AND difficulty = ?'
            params.append(dificuldade)
            
        # Prioriza áreas fracas
        if weak_areas:
            query += f''' 
            ORDER BY 
            CASE 
                WHEN area IN ({','.join(['?']*len(weak_areas))}) THEN 1 
                ELSE 2 
            END, 
            RANDOM()
            '''
            params.extend(weak_areas)
        else:
            query += ' ORDER BY RANDOM()'
            
        query += ' LIMIT ?'
        params.append(num_questoes)
        
        cursor.execute(query, params)
        questoes = cursor.fetchall()
        
        return [dict(q) for q in questoes]
        
    except Exception as e:
        logger.error(f"Erro ao buscar questões: {e}")
        return []
from performance_system import PerformanceAnalyzer, StudyMaterialGenerator, ProgressTracker

class MotivationalCoach:
    """Classe para gerenciar mensagens e estratégias motivacionais"""
    
    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 StudyAnalytics:
    """Classe para análise avançada do progresso do estudante"""
    
    def __init__(self, db_connection):
        self.conn = db_connection

    def calculate_study_metrics(self, user_id: str) -> Dict:
        """Calcula métricas avançadas de estudo"""
        cursor = self.conn.cursor()
        
        # Horas totais de estudo
        cursor.execute('''
            SELECT SUM(horas_estudadas) FROM study_progress 
            WHERE user_id = ?
        ''', (user_id,))
        total_horas = cursor.fetchone()[0] or 0
        
        # Desempenho por área
        cursor.execute('''
            SELECT topic, AVG(performance_score) 
            FROM study_progress 
            WHERE user_id = ? 
            GROUP BY topic
        ''', (user_id,))
        desempenho_por_area = dict(cursor.fetchall())
        
        # Consistência de estudos (dias consecutivos)
        cursor.execute('''
            SELECT date FROM study_progress 
            WHERE user_id = ? 
            ORDER BY date DESC
        ''', (user_id,))
        datas = [row[0] for row in cursor.fetchall()]
        dias_consecutivos = self.calculate_streak(datas)
        
        return {
            "total_horas": total_horas,
            "desempenho_por_area": desempenho_por_area,
            "dias_consecutivos": dias_consecutivos
        }

    @staticmethod
    def calculate_streak(dates: List[str]) -> int:
        if not dates:
            return 0
        
        dates = [datetime.strptime(d, '%Y-%m-%d').date() for d in dates]
        dates.sort(reverse=True)
        
        streak = 1
        for i in range(len(dates)-1):
            if (dates[i] - dates[i+1]).days == 1:
                streak += 1
            else:
                break
        return streak

class CRMJABot:
    """Assistente de estudos aprimorado para o Revalida"""
    
    def __init__(self):
        self.db = RevalidaDatabase()
        self.planner = StudyPlanGenerator(self.db)
        self.coach = MotivationalCoach()
        self.analytics = StudyAnalytics(self.db.conn)
        self.performance = PerformanceAnalyzer(self.db.conn)
        self.material_gen = StudyMaterialGenerator(self.db.conn)
        self.tracker = ProgressTracker(self.db.conn)

        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
        
        self.commands = {
            "/start": self.start_command,
            "/plano": self.create_plan,
            "/progresso": self.check_progress,
            "/questoes": self.previous_questions,
            "/estudo": self.study_mode,
            "/dica": self.get_tip,
            "/motiva": self.get_motivation,
            "/resumo": self.get_summary,
            "/ajuda": self.help_command,
            "/simulado": self.start_simulado,
            "/caso": self.start_caso_clinico,
            "/bancoquestoes": self.banco_questoes,
            "/revisao": self.modo_revisao,
            "/meta": self.set_goal,
            "/perfil": self.show_profile,
            "/configurar": self.configure_preferences
        }
        
    def start_command(self, message: str, user_id: str) -> str:
        """Mensagem inicial de boas-vindas"""
        return f"""🌟 Olá! Eu sou o crmjaBot, seu assistente pessoal para o Revalida!

Estou aqui para te ajudar a alcançar seu objetivo de aprovação! Vamos juntos nessa jornada? 

Comandos principais:
📚 /plano - Criar plano de estudos personalizado
📊 /progresso - Verificar seu progresso
📝 /questoes - Praticar questões anteriores
⏱ /estudo - Registrar sessão de estudo
💡 /dica - Receber dica de estudo
🌟 /motiva - Mensagem motivacional
📋 /resumo - Resumo do seu desempenho
❓ /ajuda - Ver todos os comandos

{self.coach.get_motivational_message()}

Como posso te ajudar hoje?"""

    def get_tip(self, message: str, user_id: str) -> str:
        """Fornece dica de estudo"""
        return f"💡 Dica do dia:\n\n{self.coach.get_study_tip()}"

    def get_motivation(self, message: str, user_id: str) -> str:
        """Fornece mensagem motivacional"""
        return f"✨ Mensagem motivacional:\n\n{self.coach.get_motivational_message()}"

    def get_summary(self, message: str, user_id: str) -> str:
        """Fornece resumo completo do progresso"""
        try:
            metrics = self.analytics.calculate_study_metrics(user_id)
            
            response = f"""📊 Resumo do seu desempenho:

⏱ Total de horas estudadas: {metrics['total_horas']:.1f}h
🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos

📈 Desempenho por área:"""
            
            for area, score in metrics['desempenho_por_area'].items():
                response += f"\n- {area}: {score:.1f}%"
            
            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_plan(self, message: str, user_id: str) -> str:
        """Criar plano de estudos personalizado com elementos motivacionais"""
        try:
            parts = message.split()
            if len(parts) < 3:
                return """📚 Para criar seu plano personalizado, preciso de algumas informações:

Formato: /plano horas_diarias AAAA-MM-DD área1,área2

Exemplo: /plano 4 2024-07-15 ClínicaMédica,Cirurgia

As áreas disponíveis são:
- ClínicaMédica
- Cirurgia
- Pediatria
- GinecologiaObstetrícia
- MedicinaFamília
- SaúdeMental"""

            horas = int(parts[1])
            data_alvo = parts[2]
            areas_fracas = parts[3].split(',') if len(parts) > 3 else []
            
            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas_fracas)
            
            response = f"""✨ Seu Plano de Estudos Personalizado está pronto! 

{self.coach.get_motivational_message()}

📚 Distribuição semanal:"""

            for semana, topicos in plano.items():
                response += f"\n\n📅 {semana}:"
                for topico, horas in topicos.items():
                    response += f"\n  ▪ {topico}: {horas}h"

            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
            
            return response
            
        except Exception as e:
            return f"Erro ao criar plano: {str(e)}"

    def check_progress(self, message: str, user_id: str) -> str:
        """Verifica o progresso com feedback motivacional"""
        try:
            metrics = self.analytics.calculate_study_metrics(user_id)
            
            response = f"""📊 Seu Progresso:

⭐ Incrível! Você já estudou {metrics['total_horas']:.1f} horas no total!
🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos

📈 Desempenho por área:"""
            
            for area, score in metrics['desempenho_por_area'].items():
                response += f"\n  ▪ {area}: {score:.1f}%"

            response += f"\n\n{self.coach.get_motivational_message()}"
            
            if metrics['dias_consecutivos'] >= 7:
                response += "\n\n🏆 Parabéns pela dedicação consistente!"
            
            return response
            
        except Exception as e:
            return f"Erro ao verificar progresso: {str(e)}"

    def study_mode(self, message: str, user_id: str) -> str:
        """Registra sessão de estudo com feedback motivacional"""
        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.conn.cursor()
            cursor.execute('''
            INSERT INTO study_progress
            (user_id, date, topic, horas_estudadas, questions_answered, performance_score)
            VALUES (?, ?, ?, ?, ?, ?)
            ''', (user_id, datetime.now().date(), area, horas, 0, 0.0))
            self.db.conn.commit()
            
            metrics = self.analytics.calculate_study_metrics(user_id)
            
            response = f"""✅ Ótimo trabalho! Registrei {horas}h de estudo em {area}

⭐ Total de horas estudadas: {metrics['total_horas']:.1f}h
🎯 Sequência atual: {metrics['dias_consecutivos']} dias

{self.coach.get_motivational_message()}

💡 Dica: {self.coach.get_study_tip()}"""
            
            return response
            
        except Exception as e:
            return f"Erro ao registrar estudo: {str(e)}"

    def generate_response(self, message: str, history: List) -> str:
        """Gera resposta personalizada usando o pipeline de QA"""
        if not self.qa_pipeline:
            return f"""Desculpe, o modelo de linguagem não está disponível no momento.

{self.coach.get_motivational_message()}

Use /ajuda para ver os comandos disponíveis!"""
            
        try:
            context = "\n".join([h[1] for h in history[-3:]] if history else "")
            
            result = self.qa_pipeline(
                question=message,
                context=context or "Você é o crmjaBot, um assistente motivacional e educacional para o Revalida."
            )
            
            return f"""{result['answer']}

{self.coach.get_motivational_message()}"""
        except Exception as e:
            return f"Erro ao gerar resposta: {str(e)}"

    def help_command(self, message: str, user_id: str) -> str:
        """Mostra todos os comandos disponíveis"""
        return """🤖 Comandos do crmjaBot:

📚 Estudos:
/plano - Criar plano de estudos personalizado
/estudo - Registrar sessão de estudo
/questoes - Praticar questões anteriores

📊 Acompanhamento:
/progresso - Ver seu progresso
/resumo - Resumo completo do desempenho

✨ Motivacional:
/dica - Receber dica de estudo
/motiva - Mensagem motivacional

❓ Ajuda:
/start - Iniciar/reiniciar bot
/ajuda - Ver esta mensagem

Estou aqui para te ajudar! Como posso ser útil hoje?"""

def create_interface():
    """Criar interface Gradio"""
    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()