"""
Script de Otimização de Performance
Otimiza o agente para melhor desempenho em produção
"""

import os
import sys

# Adicionar diretório app ao path
sys.path.append(os.path.join(os.path.dirname(__file__), 'app'))

def optimize_model_loading():
    """Otimiza carregamento do modelo"""
    print("🚀 Otimizando carregamento do modelo...")
    
    # Criar versão otimizada do agente principal
    optimized_agent_code = '''"""
Agente de IA para Ensino de Italiano - Versão Otimizada
Versão otimizada para produção com carregamento lazy e cache
"""

from langchain.llms import HuggingFacePipeline
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
import os
import logging
from typing import Dict, List, Tuple, Optional

# Configurar logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class OptimizedItalianTutorAgent:
    """
    Versão otimizada do agente de italiano para produção
    """
    
    def __init__(self, model_name: str = "microsoft/DialoGPT-medium"):
        """
        Inicializa com modelo mais leve por padrão
        """
        self.model_name = model_name
        self.llm = None
        self.conversation = None
        
        # Configurar memória
        self.memory = ConversationBufferWindowMemory(
            k=5,  # Reduzido para melhor performance
            return_messages=True
        )
        
        # Histórico simplificado
        self.error_history = []
        self.quiz_history = []
        
        # Lazy loading - só carrega quando necessário
        self._model_loaded = False
    
    def _load_model_if_needed(self):
        """Carrega modelo apenas quando necessário"""
        if self._model_loaded:
            return
        
        try:
            logger.info(f"Carregando modelo: {self.model_name}")
            
            # Tentar importar dependências
            from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
            
            # Carregar modelo leve
            tokenizer = AutoTokenizer.from_pretrained(self.model_name)
            model = AutoModelForCausalLM.from_pretrained(self.model_name)
            
            # Configurar pipeline otimizado
            text_pipeline = pipeline(
                "text-generation",
                model=model,
                tokenizer=tokenizer,
                max_length=256,  # Reduzido para melhor performance
                temperature=0.7,
                do_sample=True,
                device=-1  # CPU para compatibilidade
            )
            
            self.llm = HuggingFacePipeline(pipeline=text_pipeline)
            
            # Configurar prompt otimizado
            self.prompt_template = PromptTemplate(
                input_variables=["history", "input"],
                template="""Você é um tutor de italiano. Seja conciso e útil.

Histórico: {history}
Usuário: {input}
Tutor:"""
            )
            
            # Configurar conversação
            self.conversation = ConversationChain(
                llm=self.llm,
                memory=self.memory,
                prompt=self.prompt_template,
                verbose=False
            )
            
            self._model_loaded = True
            logger.info("Modelo carregado com sucesso!")
            
        except Exception as e:
            logger.error(f"Erro ao carregar modelo: {e}")
            # Fallback para modo mock
            self._setup_mock_mode()
    
    def _setup_mock_mode(self):
        """Configura modo mock para desenvolvimento/teste"""
        logger.info("Configurando modo mock...")
        
        class MockLLM:
            def predict(self, input_text):
                # Respostas simples baseadas em palavras-chave
                input_lower = input_text.lower()
                
                if "ciao" in input_lower or "olá" in input_lower:
                    return "Ciao! Come stai? (Olá! Como você está?)"
                elif "traduz" in input_lower or "tradução" in input_lower:
                    return "Claro! Posso ajudar com traduções português ↔ italiano."
                elif "quiz" in input_lower:
                    return "Vamos fazer um quiz! Qual tópico você gostaria de praticar?"
                elif "gramática" in input_lower:
                    return "Posso explicar regras gramaticais italianas. Qual sua dúvida?"
                elif "verbo" in input_lower:
                    return "Os verbos italianos têm conjugações específicas. Qual verbo você quer aprender?"
                else:
                    return "Interessante! Como posso ajudar você a aprender italiano?"
        
        self.conversation = MockLLM()
        self._model_loaded = True
        logger.info("Modo mock configurado!")
    
    def process_message(self, user_input: str) -> str:
        """Processa mensagem do usuário"""
        self._load_model_if_needed()
        
        try:
            if hasattr(self.conversation, 'predict'):
                # Modo normal ou mock
                if hasattr(self.conversation, 'memory'):
                    # Modo normal com LangChain
                    response = self.conversation.predict(input=user_input)
                else:
                    # Modo mock
                    response = self.conversation.predict(user_input)
            else:
                response = "Desculpe, o sistema está inicializando. Tente novamente."
            
            return response
            
        except Exception as e:
            logger.error(f"Erro ao processar mensagem: {e}")
            return f"Desculpe, ocorreu um erro: {str(e)}"
    
    def _detect_interaction_type(self, user_input: str) -> str:
        """Detecta tipo de interação de forma otimizada"""
        user_input_lower = user_input.lower()
        
        if any(word in user_input_lower for word in ["traduz", "tradução", "significa"]):
            return "translation_request"
        elif any(word in user_input_lower for word in ["quiz", "teste", "pergunta"]):
            return "quiz_request"
        elif any(word in user_input_lower for word in ["gramática", "regra", "verbo"]):
            return "grammar_question"
        else:
            return "general_conversation"
    
    def get_conversation_history(self) -> List:
        """Retorna histórico simplificado"""
        if hasattr(self.memory, 'chat_memory'):
            return self.memory.chat_memory.messages
        return []
    
    def clear_memory(self):
        """Limpa memória"""
        self.memory.clear()
        self.error_history.clear()
        self.quiz_history.clear()


def create_italian_tutor() -> OptimizedItalianTutorAgent:
    """Cria instância otimizada do agente"""
    return OptimizedItalianTutorAgent()
'''
    
    # Salvar versão otimizada
    with open('app/italian_tutor_agent_optimized.py', 'w', encoding='utf-8') as f:
        f.write(optimized_agent_code)
    
    print("✅ Versão otimizada do agente criada")
    return True

def optimize_requirements():
    """Otimiza requirements para produção"""
    print("📦 Otimizando requirements...")
    
    # Requirements otimizados para produção
    optimized_requirements = """# Dependências principais (versões específicas para estabilidade)
gradio>=4.0.0,<5.0.0
langchain>=0.0.350,<0.1.0
transformers>=4.35.0,<5.0.0

# Dependências opcionais (apenas se necessário)
torch>=2.0.0,<3.0.0; platform_machine != "aarch64"
accelerate>=0.24.0,<1.0.0; platform_machine != "aarch64"

# Dependências básicas
numpy>=1.24.0,<2.0.0
requests>=2.31.0,<3.0.0
python-dateutil>=2.8.2,<3.0.0

# Para Hugging Face Spaces
huggingface_hub>=0.19.0,<1.0.0
"""
    
    with open('requirements_optimized.txt', 'w', encoding='utf-8') as f:
        f.write(optimized_requirements)
    
    print("✅ Requirements otimizados criados")
    return True

def create_lightweight_interface():
    """Cria versão leve da interface"""
    print("🎨 Criando interface otimizada...")
    
    lightweight_interface = '''"""
Interface Gradio Otimizada
Versão leve para produção
"""

import gradio as gr
import sys
import os

# Adicionar diretório app ao path
sys.path.append(os.path.join(os.path.dirname(__file__), 'app'))

class LightweightInterface:
    """Interface otimizada para produção"""
    
    def __init__(self):
        self.agent = None
        self.setup_interface()
    
    def _get_agent(self):
        """Lazy loading do agente"""
        if self.agent is None:
            try:
                from italian_tutor_agent_optimized import create_italian_tutor
                self.agent = create_italian_tutor()
            except ImportError:
                # Fallback para agente mock
                self.agent = self._create_mock_agent()
        return self.agent
    
    def _create_mock_agent(self):
        """Cria agente mock para desenvolvimento"""
        class MockAgent:
            def process_message(self, msg):
                return f"Echo: {msg} (Modo de desenvolvimento - instale as dependências para funcionalidade completa)"
        return MockAgent()
    
    def setup_interface(self):
        """Configura interface simplificada"""
        
        with gr.Blocks(title="Tutor de Italiano IA", theme=gr.themes.Soft()) as self.interface:
            
            gr.Markdown("""
            # 🇮🇹 Tutor de Italiano com IA
            
            Seu assistente pessoal para aprender italiano!
            """)
            
            # Chat principal
            with gr.Row():
                with gr.Column(scale=4):
                    self.chatbot = gr.Chatbot(
                        label="Conversa com seu Tutor",
                        height=400
                    )
                    
                    with gr.Row():
                        self.msg_input = gr.Textbox(
                            placeholder="Digite sua mensagem...",
                            show_label=False,
                            scale=4
                        )
                        send_btn = gr.Button("Enviar", variant="primary", scale=1)
                
                with gr.Column(scale=1):
                    gr.Markdown("### 💡 Dicas Rápidas")
                    gr.Markdown("""
                    - Digite "Ciao!" para começar
                    - Peça traduções: "Como se diz..."
                    - Faça perguntas sobre gramática
                    - Solicite quizzes para praticar
                    """)
                    
                    clear_btn = gr.Button("🗑️ Limpar Chat", variant="secondary")
            
            # Configurar eventos
            send_btn.click(
                self.process_message,
                inputs=[self.msg_input, self.chatbot],
                outputs=[self.chatbot, self.msg_input]
            )
            
            self.msg_input.submit(
                self.process_message,
                inputs=[self.msg_input, self.chatbot],
                outputs=[self.chatbot, self.msg_input]
            )
            
            clear_btn.click(
                lambda: ([], ""),
                outputs=[self.chatbot, self.msg_input]
            )
    
    def process_message(self, message, history):
        """Processa mensagem do usuário"""
        if not message.strip():
            return history, ""
        
        try:
            agent = self._get_agent()
            response = agent.process_message(message)
            history.append((message, response))
            return history, ""
        except Exception as e:
            error_msg = f"Erro: {str(e)}"
            history.append((message, error_msg))
            return history, ""
    
    def launch(self, **kwargs):
        """Lança a interface"""
        return self.interface.launch(**kwargs)


def create_interface():
    """Cria interface otimizada"""
    return LightweightInterface()


def main():
    """Função principal otimizada"""
    print("🚀 Iniciando Tutor de Italiano (Versão Otimizada)...")
    
    try:
        interface = create_interface()
        interface.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=False,
            debug=False
        )
    except Exception as e:
        print(f"Erro: {e}")


if __name__ == "__main__":
    main()
'''
    
    with open('app_optimized.py', 'w', encoding='utf-8') as f:
        f.write(lightweight_interface)
    
    print("✅ Interface otimizada criada")
    return True

def create_deployment_config():
    """Cria configurações para deploy"""
    print("⚙️ Criando configurações de deploy...")
    
    # Dockerfile para containerização (opcional)
    dockerfile = """FROM python:3.11-slim

WORKDIR /app

# Instalar dependências do sistema
RUN apt-get update && apt-get install -y \\
    git \\
    && rm -rf /var/lib/apt/lists/*

# Copiar requirements
COPY requirements_optimized.txt requirements.txt

# Instalar dependências Python
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código
COPY . .

# Expor porta
EXPOSE 7860

# Comando para executar
CMD ["python", "app_optimized.py"]
"""
    
    with open('Dockerfile', 'w') as f:
        f.write(dockerfile)
    
    # Configuração para Hugging Face Spaces
    hf_config = """title: Tutor de Italiano IA
emoji: 🇮🇹
colorFrom: green
colorTo: blue
sdk: gradio
sdk_version: 4.0.0
app_file: app_optimized.py
pinned: false
license: mit
"""
    
    with open('README_HF.md', 'w') as f:
        f.write(hf_config)
    
    print("✅ Configurações de deploy criadas")
    return True

def main():
    """Executa todas as otimizações"""
    print("🔧 OTIMIZAÇÃO DE PERFORMANCE")
    print("=" * 40)
    
    optimizations = [
        ("Carregamento do Modelo", optimize_model_loading),
        ("Requirements", optimize_requirements),
        ("Interface Leve", create_lightweight_interface),
        ("Configurações de Deploy", create_deployment_config)
    ]
    
    success_count = 0
    
    for name, func in optimizations:
        print(f"\\n{name}:")
        try:
            if func():
                success_count += 1
                print(f"✅ {name} concluído")
            else:
                print(f"❌ {name} falhou")
        except Exception as e:
            print(f"❌ {name} erro: {e}")
    
    print("\\n" + "=" * 40)
    print(f"📊 RESULTADO: {success_count}/{len(optimizations)} otimizações concluídas")
    
    if success_count == len(optimizations):
        print("🎉 TODAS AS OTIMIZAÇÕES CONCLUÍDAS!")
        print("✅ Sistema otimizado para produção")
    else:
        print("⚠️  ALGUMAS OTIMIZAÇÕES FALHARAM")
    
    return success_count == len(optimizations)

if __name__ == "__main__":
    main()