conexion_firebase.py

import firebase_admin
from datetime import datetime
from firebase_admin import auth
from firebase_admin import firestore
from firebase_admin import credentials

firebase_cred = credentials.Certificate('archivos/config.json')
firebase_admin.initialize_app(firebase_cred)

db = firestore.client(database_id='nowme')
#dato es el dato que traes  como el nombre del user. 
#info es la info de ese dato que estás buscando, como token.
def obtenDato(coleccion, documento, info):
    #Future: Tentativamente ésta parte podría solo hacerse una vez y vivir en la app para ser reutilizado.
    
    #Primero debemos definir la referencia al documento, o sea a la hoja de usuario.
    doc_ref = db.collection(coleccion).document(documento)    
    documento = doc_ref.get()
    
    #Recuerda la conversión a diccionario.
    documento = doc_ref.get() 
    diccionario = documento.to_dict()
    return diccionario.get(info)

def obtenAllDatos(coleccion, documento):

    doc_ref = db.collection(coleccion).document(documento) 
    documento = doc_ref.get()

    #Recuerda la conversión a diccionario.
    documento = doc_ref.get() 
    diccionario = documento.to_dict()

    return diccionario

def editaDato(coleccion, dato, info, contenido):
        
    #Primero debemos definir la referencia al documento, o sea a la hoja de usuario.
    doc_ref = db.collection(coleccion).document(dato)
        
    doc_ref.update({
        info: contenido,
    })

def creaDato(coleccion, dato, info, contenido):

    #Primero debemos definir la referencia al documento, o sea a la hoja de usuario.
    doc_ref = db.collection(coleccion).document(dato)
    
    doc_ref.set({
        info: contenido,
    })

def registraLog(servidor_val, prompt_val, modelo_val, seed_val):
    """
    Agrega un nuevo documento a la colección 'logs'.
    El ID del documento es la fecha y hora actual en formato string.
    Los campos del documento son 'servidor', 'prompt', 'modelo' y 'seed'.

    Args:
        servidor_val (str): El nombre o ID del servidor.
        prompt_val (str): El valor del campo 'prompt'.
        modelo_val (str): El valor del campo 'modelo'.
        seed_val (int): El valor del campo 'seed'.
    """
    try:
        # 1. Generar el ID del documento (fecha y hora actual formateada)
        # Es importante usar una zona horaria si tus logs vienen de diferentes lugares
        # o si quieres que el timestamp refleje una hora local específica.
        # Por defecto, datetime.now() usa la hora local de tu sistema.
        # Si prefieres UTC (recomendado para consistencia global), puedes usar datetime.now(pytz.utc).
        
        # Obtenemos la hora actual del sistema
        now = datetime.now() 
        # Formateamos la hora para que sea el ID del documento
        document_id_fecha_hora = now.strftime("%Y-%m-%d %H:%M:%S")

        nombre_final = servidor_val + " - " + document_id_fecha_hora

        # 2. Definir la referencia al documento específico con el ID de fecha y hora
        doc_ref = db.collection('logs').document(nombre_final)

        # 3. Definir los datos del log
        datos_log = {
            'servidor': servidor_val,
            'prompt': prompt_val,
            'modelo': modelo_val,
            'seed': seed_val,
            # Opcional: También puedes guardar el timestamp como un campo Timestamp
            # esto facilita consultas de rango si la fecha/hora del ID no es perfecta
            # o si necesitas ordenar por milisegundos.
            'timestamp_creacion': firestore.SERVER_TIMESTAMP
        }

        # 4. Guardar los datos en el documento
        # Usamos .set(). Si un log ya existe para ese EXACTO segundo, se sobrescribirá.
        # Si esto es una preocupación (dos logs en el mismo segundo), podríamos añadir
        # milisegundos al ID o usar un ID automático y un campo de timestamp.
        doc_ref.set(datos_log)

        #print(f"✔️ Log agregado exitosamente en 'logs/{document_id_fecha_hora}'.")
        print(f"   Datos: Servidor='{servidor_val}', Prompt='{prompt_val}'...")

    except Exception as e:
        print(f"❌ Error al agregar log a Firestore: {e}")
        # Considera registrar el error o manejarlo de forma más robusta.


def buscar_log_por_prompt(valor_prompt):
    """
    Busca documentos en la colección 'logs' donde el campo 'prompt' coincide
    con el valor_prompt especificado.

    Args:
        valor_prompt (str): El valor exacto del prompt a buscar.

    Returns:
        list: Una lista de diccionarios, donde cada diccionario representa un documento
              que coincide con la búsqueda. Incluye el ID del documento.
    """
    print(f"\n--- Buscando logs con prompt: '{valor_prompt}' ---")

    # --- CAMBIO AQUÍ: Usando firestore.FieldFilter en lugar de .where() directamente ---
    query_results = db.collection('logs').where(
        filter=firestore.FieldFilter('prompt', '==', valor_prompt)
    ).get()

    logs_encontrados = []
    if not query_results:
        print(f"No se encontraron documentos con el prompt '{valor_prompt}'.")
        return []

    for doc in query_results:
        log_data = doc.to_dict()
        log_data['id'] = doc.id # Añade el ID del documento al diccionario de datos
        logs_encontrados.append(log_data)
        
    return logs_encontrados

def incrementar_campo_numerico(collection_name, document_id, field_name, amount=1):
    """
    Incrementa un campo numérico en un documento de Firestore de forma atómica.
    Si el documento no existe, lo crea e inicializa el campo con el 'amount'.
    Si el campo no existe en un documento existente, lo inicializa y aplica el incremento.

    Args:
        collection_name (str): El nombre de la colección.
        document_id (str): El ID del documento.
        field_name (str): El nombre del campo numérico a incrementar.
        amount (int/float): La cantidad por la cual incrementar (puede ser negativo para decrementar).
    """
    doc_ref = db.collection(collection_name).document(document_id)

    try:
        # Usamos .set() con merge=True para comportamiento de "upsert".
        # Si el documento no existe, lo crea.
        # Si el campo no existe, lo crea e inicializa con 'amount'.
        # Si el campo ya existe, lo incrementa con 'amount'.
        doc_ref.set(
            {field_name: firestore.Increment(amount)},
            merge=True  # Esta es la clave para que se cree si no existe y no sobrescriba otros campos
        )
        print(f"✔️ Campo '{field_name}' en el documento '{document_id}' actualizado/creado e incrementado en {amount}.")
    except Exception as e:
        print(f"❌ Error al operar en el campo '{field_name}' del documento '{document_id}': {e}")

def obtener_documentos_habilitados(coleccion):
    """
    Obtiene una lista de los IDs de todos los documentos en la colección
    cuyo campo 'habilitado' es true.

    Args:
        coleccion (str): El nombre de la colección a consultar.

    Returns:
        list: Una lista de strings, donde cada string es el ID de un documento
              habilitado.
    """
    print(f"--- Buscando documentos habilitados en la colección '{coleccion}' ---")
    
    try:
        # 1. Referencia a la colección con el nombre del parámetro
        query_results = db.collection(coleccion).where(
            filter=firestore.FieldFilter('habilitado', '==', True)
        ).get()
        
        # 2. Itera sobre los resultados y almacena solo el ID en una lista
        # Usamos una lista por comprensión para una mayor eficiencia y simplicidad
        documentos_habilitados_ids = [doc.id for doc in query_results]
        
        if not documentos_habilitados_ids:
            print("❌ No se encontraron documentos habilitados.")
            return []
            
        print(f"✔️ Se encontraron {len(documentos_habilitados_ids)} IDs de documentos.")
        return documentos_habilitados_ids
        
    except Exception as e:
        print(f"❌ Error al obtener documentos habilitados: {e}")
        return []