from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_core.messages import HumanMessage
from langchain_aws import ChatBedrock
import boto3
from botocore.config import Config
import os

# 1️⃣ Configuramos la memoria persistente en SQLite
db_path = os.path.join(os.path.dirname(__file__), "chat_history.db")
chat_history = SQLChatMessageHistory(
    session_id="user_session_1",
    connection_string=f"sqlite:///{db_path}"
)

# 2️⃣ Configuramos el cliente de Bedrock
bedrock_client = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-1',
    config=Config(retries={'max_attempts': 3})
)

# 3️⃣ Definimos el LLM (usando Google Gemma a través de AWS Bedrock)
llm = ChatBedrock(
    model_id="global.amazon.nova-2-lite-v1:0",
    client=bedrock_client,
    temperature=0.2,
    max_tokens=1024
)
# 4️⃣ Creamos el agente con historial de mensajes
def create_agent_with_memory():
    def process_input(user_input: str) -> str:
        chat_history.add_user_message(user_input)
        
        # Obtener el historial completo para mostrar contexto
        messages = chat_history.messages
        print(f"\n📚 Historial en memoria: {len(messages)} mensajes")
        
        try:
            response = llm.invoke(messages)
            chat_history.add_ai_message(response.content)
            return response.content
        except NotImplementedError as e:
            error_msg = f"❌ Error: {str(e)}. Limpiando historial corrupto..."
            print(error_msg)
            # Limpiar la sesión y reintentar
            chat_history.clear()
            response = llm.invoke([HumanMessage(content=user_input)])
            chat_history.add_user_message(user_input)
            chat_history.add_ai_message(response.content)
            return response.content
    
    return process_input

agent = create_agent_with_memory()

# 5️⃣ Mostrar información inicial
print("\n" + "="*60)
print("🤖 AGENTE CON MEMORIA PERSISTENTE EN SQLITE")
print("="*60)
print(f"📁 Base de datos: {db_path}")
print(f"🔑 Session ID: user_session_1")
print(f"📊 Mensajes en historial: {len(chat_history.messages)}")
print("\n💡 Prueba: Cuéntale algo, luego escribe 'exit' y vuelve a ejecutar el script.")
print("   El agente recordará lo que le dijiste.\n")
print("="*60 + "\n")

# 6️⃣ Interactuar
while True:
    user_input = input("🧑‍💻: ")
    if user_input.lower() in ["exit", "quit"]:
        print("\n👋 Hasta luego! Tu historial se guardó en SQLite.\n")
        break
    response = agent(user_input)
    print(f"🤖: {response}\n")
        
        
    

    
import os
from pathlib import Path

import boto3
from botocore.config import Config
from langchain_aws import ChatBedrock
from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_core.messages import HumanMessage, AIMessage

# ----------------------------------------------------------------------
# 1️⃣ Configuración de la memoria persistente (SQLite)
# ----------------------------------------------------------------------
BASE_DIR = Path(__file__).parent
DB_PATH = BASE_DIR / "arch_history.db"

chat_history = SQLChatMessageHistory(
    session_id="dev_arch_session",
    connection=f"sqlite:///{DB_PATH}"
)

# ----------------------------------------------------------------------
# 2️⃣ Cliente Bedrock y modelo (Gemma‑3‑27B‑IT)
# ----------------------------------------------------------------------
bedrock_client = boto3.client(
    service_name="bedrock-runtime",
    region_name="us-east-1",
    config=Config(retries={"max_attempts": 3}),
)

llm = ChatBedrock(
    model_id="us.meta.llama3-2-90b-instruct-v1:0",   # modelo disponible en Bedrock
    client=bedrock_client,
    temperature=0.2,
    max_tokens=1024,
)

# ----------------------------------------------------------------------
# 3️⃣ System prompt: especialista en Docker + PostgreSQL
# ----------------------------------------------------------------------
SYSTEM_PROMPT = (
    "Eres un asistente de desarrollo especializado en decisiones de arquitectura "
    "relacionadas con Docker y PostgreSQL. Cada vez que el usuario te indique una "
    "decisión (por ejemplo, versión de PostgreSQL, estrategia de volúmenes, "
    "configuración de redes Docker, etc.), la almacenarás en tu historial. "
    "Cuando el usuario solicite 'recuerda', deberás resumir todas las decisiones "
    "previas, manteniendo el orden cronológico y resaltando los puntos clave."
)

# ----------------------------------------------------------------------
# 4️⃣ Funciones auxiliares
# ----------------------------------------------------------------------
def add_decision(decision: str) -> str:
    """Guarda una decisión de arquitectura en el historial."""
    chat_history.add_user_message(decision)          # guardamos la decisión como mensaje del usuario
    # Generamos una confirmación del asistente (opcional)
    confirm = llm.invoke([HumanMessage(content=decision)])
    chat_history.add_ai_message(confirm.content)
    return confirm.content

def get_summary() -> str:
    """Devuelve un resumen de todas las decisiones almacenadas."""
    # Construimos el prompt que pide el resumen
    prompt = (
        f"{SYSTEM_PROMPT}\n\n"
        "Resumen de decisiones:\n"
        f"{chat_history.messages}"
    )
    response = llm.invoke([HumanMessage(content=prompt)])
    # Guardamos la respuesta del asistente en el historial
    chat_history.add_ai_message(response.content)
    return response.content

# ----------------------------------------------------------------------
# 5️⃣ Interfaz de línea de comandos
# ----------------------------------------------------------------------
def main() -> None:
    print("\n" + "=" * 60)
    print("🤖 Asistente de arquitectura Docker + PostgreSQL")
    print("=" * 60)
    print("Comandos disponibles:")
    print("  decide    → guarda una decisión")
    print("  recuerda         → muestra el resumen de decisiones")
    print("  exit / quit      → termina")
    print("=" * 60 + "\n")

    while True:
        user_input = input("🧑‍💻: ").strip()
        if not user_input:
            continue

        if user_input.lower() in {"exit", "quit"}:
            print("\n👋 ¡Hasta la próxima! Tu historial quedó guardado en SQLite.\n")
            break

        if user_input.lower().startswith("decide "):
            decision = user_input[7:].strip()
            resp = add_decision(decision)
            print(f"🤖: {resp}\n")
        elif user_input.lower() == "recuerda":
            summary = get_summary()
            print(f"\n📋 Resumen de decisiones:\n{summary}\n")
        else:
            # Si el mensaje no es un comando, lo tratamos como una pregunta genérica
            resp = llm.invoke([HumanMessage(content=user_input)])
            chat_history.add_ai_message(resp.content)
            print(f"🤖: {resp.content}\n")

if __name__ == "__main__":
    main()