fireWhale.py

import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
import time

from firebase_admin import auth

# Use the application default credentials.
cred = credentials.Certificate('config.json')
firebase_admin.initialize_app(cred)

db = firestore.client()

def obtenDatosUIDFirebase(uid):
    """
    Verifica si un UID existe en Firebase Authentication.
    Esto con el fin de evitar que se cambié el id arbitrareamente desde localstorage.

    Args:
        uid (str): El User ID (UID) que se desea verificar.

    Returns:
        bool: True si el usuario con ese UID existe, False en caso contrario.
    """
    try:
        user = auth.get_user(uid) #Obtengo el objeto con todos los datos.
        print("Ésto es el user obtenido de la comprobación: ", user)
        email = user.email
        displayName = user.display_name
        
        # Si la operación es exitosa, el usuario existe
        print(f"✔️ Usuario con UID '{uid}' encontrado en Firebase Auth: {user.email or 'sin email'}")
        return email, displayName 
    except auth.UserNotFoundError:
        # Esta excepción se lanza específicamente si el UID no existe
        print(f"❌ Usuario con UID '{uid}' NO encontrado en Firebase Auth.")
        return None, None
    except Exception as e:
        # Captura cualquier otro error (ej. problemas de conexión, permisos)
        print(f"❌ Error al verificar usuario con UID '{uid}': {e}")
        return None, None    

def obtenDato(coleccion, dato, info):
    
    print(f"Estoy dentro de obtenDato y los valores que recibí son: {coleccion}, {dato}, {info}...")
    doc_ref = db.collection(coleccion).document(dato) 

    documento = doc_ref.get()
    print("Esto es el documento obtenido: ", documento)
      
    #Quizá éste segmento que comenté era el que producia nuevos documentos sin deber.
    if documento.exists:
        print("El documento existe....")
        #Recuerda la conversión a diccionario.
        documento = doc_ref.get() 
        diccionario = documento.to_dict()
        print("Esto es el diccionario: ", diccionario)
        resultado = diccionario.get(info)
        print("Éste es el resultado...", resultado)
        return resultado
        pass #El documento si existe.        
    else:
        print("No existe el documento, es un nuevo usuario.")
        return None
        #No crees nada pero avisa que no existe.
        #creaDato(coleccion, dato, 'tokens', 5) #porque agregará 5 tokens.

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({
        # 'quote': quote,
        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({
        # 'quote': quote,
        info: contenido,
    })

def creaDatoMultiple(coleccion, dato, data_dict):
    """
    Crea un nuevo documento o sobrescribe uno existente en Firestore
    con múltiples pares de campo-contenido.

    Args:
        coleccion (str): El nombre de la colección donde se creará/actualizará el documento.
        dato (str): El ID del documento que se va a crear o sobrescribir.
        data_dict (dict): Un diccionario donde las claves son los nombres de los campos
                          y los valores son el contenido de esos campos.
                          Ej: {'nombre': 'Juan', 'edad': 30, 'activo': True}
    """
    # Primero definimos la referencia al documento
    doc_ref = db.collection(coleccion).document(dato)
    
    try:
        # Usamos .set() y le pasamos el diccionario completo.
        # Esto sobrescribirá el documento si ya existe con los nuevos datos.
        doc_ref.set(data_dict)
        
        print(f"✔️ Documento '{dato}' creado/sobrescrito en la colección '{coleccion}' con los siguientes datos:")
        for key, value in data_dict.items():
            print(f"  - {key}: {value}")
            
    except Exception as e:
        print(f"❌ Error al crear/sobrescribir documento '{dato}' en '{coleccion}': {e}")

def verificar_token(id_token):
    """Verifica el token de ID de Firebase."""
    try:
        # Verifica el token y decodifica la información del usuario
        decoded_token = auth.verify_id_token(id_token)
        uid = decoded_token['uid']
        return uid  # Retorna el UID del usuario si el token es válido
    except auth.InvalidIdTokenError as e:
        print(f"Token inválido: {e}")
        return None  # Retorna None si el token es inválido
    
def encontrar_documento_por_cus(valor_cus):
    """
    Busca un documento en la colección 'usuario' donde el campo 'cus'
    coincide con el valor_cus especificado.

    Args:
        valor_cus (str): El valor exacto del campo 'cus' a buscar.

    Returns:
        tuple: Una tupla (document_id, document_data) si se encuentra,
                o (None, None) si no se encuentra o hay un error.
                Retorna solo el primer documento encontrado si hay múltiples coincidencias.
    """
    print(f"\n--- Buscando documento en 'usuario' con cus: '{valor_cus}' ---")

    try:
        # Realizamos la consulta: filtra por documentos donde 'cus' sea igual a valor_cus
        query_results = db.collection('usuarios').where(
            filter=firestore.FieldFilter('cus', '==', valor_cus)
        ).limit(1).get() # Agregamos .limit(1) porque esperas un único documento

        if not query_results:
            print(f"❌ No se encontró ningún documento con 'cus' = '{valor_cus}'.")
            return None, None

        # Si se encuentra, query_results será una lista de instantáneas de documentos
        # Tomamos el primer resultado (ya que usamos limit(1))
        doc_snapshot = query_results[0]
        
        doc_id = doc_snapshot.id
        doc_data = doc_snapshot.to_dict()
        
        print(f"✔️ Documento encontrado: ID='{doc_id}', Datos: {doc_data}")
        return doc_id

    except Exception as e:
        print(f"❌ Error al buscar documento por 'cus': {e}")
        return None, None
    
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}")