# aduc_framework/managers/gemini_manager.py
#
# Versão 3.0.0 (Com Gerenciamento de Memória Flexível)
#
# Esta versão evolui o GeminiManager para suportar conversas com estado
# (com memória), mantendo a capacidade de operar sem estado.
# Introduz um gatilho `restart_session=True` para controle explícito
# sobre o ciclo de vida da memória, evitando contaminação de contexto.

import os
import logging
from PIL import Image
import google.generativeai as genai
from typing import List, Any, Optional

logger = logging.getLogger(__name__)

class GeminiManager:
    """
    Gerencia interações com a API do Google Gemini, com suporte opcional
    para sessões de chat com memória e um gatilho de reinicialização.
    """
    def __init__(self):
        """
        Inicializa o manager. Carrega a chave da API e configura o modelo.
        """
        self.api_key = os.environ.get("GEMINI_API_KEY")
        self.model = None
        self.chat_session = None # Armazena a sessão de chat com memória ativa

        if self.api_key:
            try:
                genai.configure(api_key=self.api_key)
                # Usando um modelo recente e capaz
                self.model = genai.GenerativeModel('gemini-2.0-flash') 
                logger.info("GeminiManager (V3 com Memória) inicializado com sucesso.")
            except Exception as e:
                logger.error(f"Falha ao configurar a API do Gemini. Verifique a chave e as permissões. Erro: {e}")
                self.model = None
        else:
            logger.warning("Variável de ambiente GEMINI_API_KEY não encontrada. GeminiManager está desabilitado.")
            
    def _check_model(self):
        """Verificação interna para garantir que o modelo está pronto para uso."""
        if not self.model:
            raise RuntimeError("O modelo Gemini não está inicializado. Verifique a chave da API (GEMINI_API_KEY).")

    def process_turn(
        self, 
        prompt_text: str, 
        image_list: Optional[List[Image.Image]] = None, 
        use_memory: bool = False,
        restart_session: bool = False
    ) -> str:
        """
        Ponto de entrada principal. Processa uma requisição textual ou multimodal,
        com gerenciamento de memória opcional.

        Args:
            prompt_text (str): O prompt textual a ser enviado.
            image_list (Optional[List[Image.Image]]): Lista de imagens a serem incluídas na requisição.
            use_memory (bool): Se True, utiliza ou cria uma sessão de chat com memória (stateful).
                               Se False, faz uma chamada única (stateless).
            restart_session (bool): Se True, força o descarte da sessão de memória atual
                                    e o início de uma nova na próxima chamada com `use_memory=True`.
        """
        self._check_model()
        
        # --- Lógica do Gatilho de Reinicialização ---
        if restart_session and self.chat_session is not None:
            logger.info("Gatilho de reinicialização acionado. Descartando sessão de chat anterior.")
            self.chat_session = None
            # Se o objetivo era apenas reiniciar, podemos retornar sem fazer uma chamada.
            if not prompt_text:
                return ""
        
        # Constrói o conteúdo a ser enviado
        prompt_parts = []
        if prompt_text:
            prompt_parts.append(prompt_text)
        if image_list:
            prompt_parts.extend(image_list)

        # Se não houver nada a ser enviado, retorna uma string vazia.
        if not prompt_parts:
            return ""

        try:
            # --- Lógica de Gerenciamento de Memória ---
            if use_memory:
                if self.chat_session is None:
                    logger.info("Iniciando nova sessão de chat com memória (stateful).")
                    self.chat_session = self.model.start_chat(history=[])
                
                logger.info("Enviando mensagem para a sessão de chat com memória...")
                response = self.chat_session.send_message(prompt_parts)
            else:
                # Modo stateless (sem memória)
                logger.info("Enviando requisição sem memória (stateless)...")
                response = self.model.generate_content(prompt_parts)
            
            # Extrai e retorna o texto da resposta
            response_text = response.text
            logger.debug(f"Gemini respondeu com texto bruto: {response_text[:500]}...")
            return response_text

        except Exception as e:
            logger.error(f"GEMINI_MANAGER: Falha na chamada da API: {e}", exc_info=True)
            # Em caso de erro na comunicação, é seguro zerar a sessão para evitar um estado corrompido.
            self.chat_session = None
            raise RuntimeError(f"Erro na comunicação com a API do Gemini: {e}")

# --- Instância Singleton ---
# Esta instância única será importada por outros componentes, como o Neura_Link.
gemini_manager_singleton = GeminiManager()