funciones.py

import stripe
import globales

stripe.api_key = globales.llave
   
def create_checkout_session(price_id, customer_email=None, customer_id=None):
    """
    Crea una nueva Checkout Session para un pago único.

    Args:
        price_id (str): El ID del precio en Stripe para el artículo que se va a comprar.
        customer_email (str, opcional): Email para pre-rellenar o asociar con un cliente existente.
        customer_id (str, opcional): ID de un cliente existente en Stripe para asociar la sesión.

    Returns:
        str: La URL de la Checkout Session, o None si hay un error.
    """
    try:
        session_params = {
            'line_items': [{
                'price': price_id,
                'quantity': 1,
            }],
            'mode': 'payment',  #payment Para pagos únicos (one-time payment) o #subscription
            'success_url': 'https://app.splashmix.ink/', #'https://tudominio.com/gracias?session_id={CHECKOUT_SESSION_ID}'
            'cancel_url': 'https://app.splashmix.ink/',
            'locale': 'es', #'es' # Establece el idioma del checkout a español
            'client_reference_id': 'HERC'
        }

        print("Estoy por entrar a checar el customer id que es: ", customer_id)

        # Opciones para el cliente
        if customer_id:            
            session_params['customer'] = customer_id            
        elif customer_email:
            session_params['customer_email'] = customer_email
            print("Salí del elif")
        else:
            print("Entré al else...")
            # Si no se provee ni customer_id ni customer_email, Stripe puede crear uno si es necesario
            # O podrías pedir el email en el formulario de Checkout.
            pass

        # Opcional: Agregar información de envío si aplica (para productos físicos)
        # session_params['shipping_address_collection'] = {'allowed_countries': ['US', 'CA', 'MX']}

        # Opcional: Permitir códigos promocionales
        # session_params['allow_promotion_codes'] = True

        # Opcional: Agregar metadata a la sesión (no al pago final directamente, pero útil para webhooks)
        # session_params['metadata'] = {'order_id': 'ORD12345', 'user_id': 'user_abc'}

        session = stripe.checkout.Session.create(**session_params)

        print(f"Checkout Session creada exitosamente. ID: {session.id}")
        print(f"URL de redirección: {session.url}")
        return session.url

    except stripe.error.StripeError as e:
        print(f"Error de Stripe al crear la Checkout Session: {e}")
        return None
    except Exception as e:
        print(f"Ocurrió un error inesperado al crear la Checkout Session: {e}")
        return None
    
def create_stripe_customer(email, firebase_user=None, site=None):
    """
    Busca un cliente existente en Stripe, priorizando el Firebase User ID usando Customer.search.
    Si el cliente no existe por Firebase User ID, intenta buscar por email.
    Si el cliente tampoco existe por email, lo crea.

    Args:
        email (str): La dirección de correo electrónico del cliente.
                     (Se usará para buscar si el cliente ya existe si no se encuentra por Firebase UID).
        firebase_user (str, opcional): El ID de usuario de Firebase. **Identificador principal para la búsqueda.**
                                       Se agregará a 'metadata'.
        site (str, opcional): El nombre del sitio de origen. Se agregará a 'metadata'.

    Returns:
        tuple: (stripe.Customer, str) donde el string indica "found_by_firebase_user", "found_by_email" o "created".
        None: Si ocurre un error.
    """
    try:
        customer_found_status = None
        found_customer = None

        # --- 1. Intentar buscar un cliente existente por firebase_user (PRIORIDAD ALTA con Customer.search) ---
        if firebase_user:
            # Usamos stripe.Customer.search para buscar en metadata.
            # Asegúrate de escapar comillas si el firebase_user pudiera contenerlas,
            # aunque los UIDs de Firebase no suelen tenerlas.
            search_query = f"metadata['firebase_user']:'{firebase_user}'"
            print(f"Buscando cliente con query: {search_query}") # Para depuración
            
            # search retorna un StripeSearchResultObject, que se itera como una lista
            existing_customers_by_firebase = stripe.Customer.search(query=search_query, limit=1)
            
            if existing_customers_by_firebase.data:
                found_customer = existing_customers_by_firebase.data[0]
                customer_found_status = "found_by_firebase_user"
                print(f"Cliente existente encontrado por Firebase User ID. ID: {found_customer.id}")
        
        # --- 2. Si no se encontró por firebase_user, intentar buscar por email ---
        if not found_customer:
            print(f"Cliente no encontrado por Firebase UID. Buscando por email: {email}") # Para depuración
            existing_customers_by_email = stripe.Customer.list(email=email, limit=1)
            if existing_customers_by_email.data:
                found_customer = existing_customers_by_email.data[0]
                customer_found_status = "found_by_email"
                print(f"Cliente existente encontrado por email. ID: {found_customer.id}")
                
                # Opcional: Si lo encontraste por email pero tiene un firebase_user nuevo o nulo, actualízalo
                # o si el site difiere, también actualizarlo.
                updated_metadata = found_customer.metadata.copy() if found_customer.metadata is not None else {}
                
                needs_update = False
                if firebase_user and updated_metadata.get('firebase_user') != firebase_user:
                    updated_metadata['firebase_user'] = firebase_user
                    needs_update = True
                if site and updated_metadata.get('site') != site:
                    updated_metadata['site'] = site
                    needs_update = True
                
                if needs_update:
                    print(f"Actualizando metadata para cliente {found_customer.id}")
                    found_customer = stripe.Customer.modify(found_customer.id, metadata=updated_metadata)
        
        # Si se encontró un cliente (por cualquiera de los métodos), lo retornamos
        if found_customer:
            return found_customer, customer_found_status

        # --- 3. Si el cliente no existe (ni por firebase_user ni por email), crearlo ---
        print(f"Cliente con email '{email}' y/o firebase_user '{firebase_user}' no encontrado. Creando nuevo cliente...")

        customer_params = {
            'email': email,
        }

        customer_metadata = {}
        if firebase_user:
            customer_metadata['firebase_user'] = firebase_user
        if site:
            customer_metadata['site'] = site

        if customer_metadata:
            customer_params['metadata'] = customer_metadata

        customer = stripe.Customer.create(**customer_params)

        print(f"Nuevo cliente creado exitosamente. ID: {customer.id}")
        return customer, "created"

    except stripe.error.StripeError as e:
        print(f"Error de Stripe al buscar o crear el cliente: {e}")
        return None
    except Exception as e:
        print(f"Ocurrió un error inesperado: {e}")
        return None