import gradio as gr
from transformers import pipeline
import sqlite3
from datetime import datetime, timedelta
import random
from typing import Dict, List
from performance_system import PerformanceAnalyzer
from simulado_system import SimuladoSystem, CasoClinicoSystem
from database.db_manager import DatabaseManager
from database.db_operations import adicionar_lote_questoes
from study_generators import StudyPlanGenerator
import logging
from twilio.rest import Client

# Configuração de logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuração Twilio para notificações via WhatsApp
TWILIO_ACCOUNT_SID = 'your_account_sid'
TWILIO_AUTH_TOKEN = 'your_auth_token'
TWILIO_WHATSAPP_NUMBER = 'whatsapp:+14155238886'
client = Client(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)

def send_whatsapp_message(to_number: str, message: str):
    try:
        client.messages.create(
            body=message,
            from_=TWILIO_WHATSAPP_NUMBER,
            to=f'whatsapp:{to_number}'
        )
        logger.info(f"Mensagem enviada para {to_number}")
    except Exception as e:
        logger.error(f"Erro ao enviar mensagem pelo WhatsApp: {e}")

class CRMJABot:
    def __init__(self):
        logger.info("Iniciando CRMJABot...")
        self.db = DatabaseManager()
        self.material_generator = StudyMaterialGenerator(self.db.get_connection())
        self.planner = StudyPlanGenerator(self.db)
        self.coach = MotivationalCoach()
        self.analytics = StudyAnalytics(self.db.get_connection())

        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,
        }

        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)

            if sucesso:
                logger.info("Questões adicionadas com sucesso!")
            else:
                logger.error(f"Erro ao adicionar questões: {mensagem}")
        except Exception as e:
            logger.error(f"Erro na inicialização do banco de questões: {e}")

    def process_message(self, message: str, user_id: str, history: List) -> str:
        command = message.split()[0]
        if command in self.commands:
            return self.commands[command](message, user_id)
        return "Comando não reconhecido. Use /ajuda para ver os comandos disponíveis."

    def start_command(self, message: str, user_id: str) -> str:
        return "\ud83c\udf1f Bem-vindo ao crmjaBot! Use /ajuda para ver os comandos disponíveis."

    def create_plan(self, message: str, user_id: str) -> str:
        try:
            parts = message.split()
            if len(parts) < 3:
                return "Erro: Informe horas diárias, data-alvo e áreas de estudo."
            horas = int(parts[1])
            data_alvo = parts[2]
            areas = parts[3].split(",") if len(parts) > 3 else []

            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas)
            self.schedule_study_notifications(user_id, horas, data_alvo)
            return f"Plano criado: {plano}"
        except Exception as e:
            logger.error(f"Erro ao criar plano: {e}")
            return "Erro ao criar plano."

    def schedule_study_notifications(self, user_id: str, horas: int, data_alvo: str):
        try:
            # Envia notificações diárias para acompanhar os estudos
            to_number = self.db.get_user_phone(user_id)  # Método fictício para obter o número do usuário
            message = f"Lembrete: Estude {horas} horas hoje para atingir sua meta até {data_alvo}!"
            send_whatsapp_message(to_number, message)
        except Exception as e:
            logger.error(f"Erro ao agendar notificações: {e}")

    def check_progress(self, message: str, user_id: str) -> str:
        try:
            metrics = self.analytics.calculate_study_metrics(user_id)
            response = f"\ud83d\udd04 Seu progresso:\n"
            response += f"Total de horas estudadas: {metrics['total_horas']}\n"
            response += f"Dias consecutivos de estudo: {metrics['dias_consecutivos']}\n"
            for area, score in metrics['desempenho_por_area'].items():
                response += f"{area}: {score:.2f}%\n"
            return response
        except Exception as e:
            logger.error(f"Erro ao verificar progresso: {e}")
            return "Erro ao verificar progresso."

    def previous_questions(self, message: str, user_id: str) -> str:
        return "Função de perguntas anteriores ainda não implementada."

    def study_mode(self, message: str, user_id: str) -> str:
        return "Função de modo de estudo ainda não implementada."

    def get_tip(self, message: str, user_id: str) -> str:
        return self.coach.get_study_tip()

    def get_motivation(self, message: str, user_id: str) -> str:
        return self.coach.get_motivational_message()

    def get_summary(self, message: str, user_id: str) -> str:
        try:
            metrics = self.analytics.calculate_study_metrics(user_id)
            response = "\ud83d\udd27 Resumo do desempenho:\n"
            response += f"Total de horas estudadas: {metrics['total_horas']}\n"
            response += f"Dias consecutivos de estudo: {metrics['dias_consecutivos']}\n"
            for area, score in metrics['desempenho_por_area'].items():
                response += f"{area}: {score:.2f}%\n"
            return response
        except Exception as e:
            logger.error(f"Erro ao gerar resumo: {e}")
            return "Erro ao gerar resumo."

    def help_command(self, message: str, user_id: str) -> str:
        return "\ud83d\udd27 Lista de comandos disponíveis: /start, /plano, /progresso, /questoes, /estudo, /dica, /motiva, /resumo, /ajuda."

class MotivationalCoach:
    def __init__(self):
        self.frases_motivacionais = [
            "\ud83c\udf1f Cada hora de estudo te aproxima mais do seu objetivo!",
            "\ud83d\udcaa Você está construindo seu futuro a cada dia!",
            "\ud83c\udfaf Mantenha o foco! O Revalida é só uma etapa da sua jornada de sucesso!",
            "\u2b50 Sua dedicação é inspiradora! Continue assim!",
            "\ud83c\udf08 Acredite no seu potencial! Você está no caminho certo!",
            "\ud83d\udcda Conhecimento é poder, e você está ficando mais forte a cada dia!",
        ]
        self.dicas_estudo = [
            "\ud83d\udccc Faça pequenas pausas a cada 45 minutos de estudo",
            "\ud83d\udca1 Revise o conteúdo do dia antes de dormir",
            "\ud83c\udfaf Estabeleça metas diárias pequenas e alcançáveis",
        ]

    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:
    def __init__(self, db_connection):
        self.conn = db_connection

    def calculate_study_metrics(self, user_id: str) -> Dict:
        cursor = self.conn.cursor()
        try:
            cursor.execute('''
                SELECT SUM(horas_estudadas) FROM study_progress WHERE user_id = ?
            ''', (user_id,))
            total_horas = cursor.fetchone()[0] or 0

            cursor.execute('''
                SELECT topic, AVG(performance_score) FROM study_progress 
                WHERE user_id = ? GROUP BY topic
            ''', (user_id,))
            desempenho_por_area = dict(cursor.fetchall())

            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)

            cursor.execute('''
                SELECT COUNT(DISTINCT date) as dias_estudo FROM study_progress
                WHERE user_id = ?
            ''', (user_id,))
            dias_estudo = cursor.fetchone()[0] or 0

            return {
                "total_horas": total_horas,
                "desempenho_por_area": desempenho_por_area,
                "dias_consecutivos": dias_consecutivos,
                "dias_estudo": dias_estudo
            }
        except sqlite3.Error as e:
            logger.error(f"Erro ao calcular métricas de estudo: {e}")
            return {}

    @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 StudyMaterialGenerator:
    def __init__(self, db_connection):
        self.db_connection = db_connection

    def gerar_material(self, tema: str) -> str:
        try:
            cursor = self.db_connection.cursor()
            query = "SELECT conteudo FROM materiais WHERE tema = ?"
            cursor.execute(query, (tema,))
            resultado = cursor.fetchone()
            return resultado[0] if resultado else "Nenhum material encontrado para o tema especificado."
        except sqlite3.Error as e:
            logger.error(f"Erro ao gerar material: {e}")
            return "Erro ao buscar material."

def create_interface():
    bot = CRMJABot()

    with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface:
        gr.Markdown("# \ud83c\udfe5 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()