from src.simple_filelock import FileLock

# Uso básico con context manager
with FileLock("/tmp/mi_app.lock"):
    # Sección crítica - solo un proceso puede ejecutar esto a la vez
    print("Ejecutando operación que requiere exclusividad...")
    hacer_algo_importante()

# Uso con timeout
try:
    with FileLock("/tmp/mi_app.lock", timeout=10, debug=True):
        # Máximo 10 segundos esperando el lock
        procesar_archivo_compartido()
except TimeoutError:
    print("No se pudo obtener el lock en 10 segundos")

import asyncio
from src.simple_filelock_async import AsyncFileLock

async def tarea_asincrona():
    async with AsyncFileLock("/tmp/mi_app_async.lock", timeout=5):
        # Sección crítica asíncrona
        print("Ejecutando tarea asíncrona exclusiva...")
        await procesar_datos_async()

# Ejecutar
asyncio.run(tarea_asincrona())

class FileLock:
    def __init__(self, lockfile_path: str, timeout: Optional[float] = None, debug: bool = False) -> None:
        """
        Crea una instancia de FileLock.
        
        Args:
            lockfile_path: Ruta del archivo de lock
            timeout: Timeout en segundos. None = esperar indefinidamente
            debug: Si True, imprime mensajes de debug
        """
        
    def __enter__(self) -> 'FileLock':
        """Adquiere el lock (usado con 'with')"""
        
    def __exit__(self, exc_type: Optional[type], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> None:
        """Libera el lock automáticamente"""
        
    def is_locked(self) -> bool:
        """Verifica si el archivo está bloqueado (solo para debugging)"""

class AsyncFileLock:
    def __init__(self, lockfile_path: str, timeout: Optional[float] = None, debug: bool = False) -> None:
        """
        Crea una instancia de AsyncFileLock.
        
        Args:
            lockfile_path: Ruta del archivo de lock
            timeout: Timeout en segundos. None = esperar indefinidamente
            debug: Si True, imprime mensajes de debug
        """
        
    async def __aenter__(self) -> 'AsyncFileLock':
        """Adquiere el lock de forma asíncrona (usado con 'async with')"""
        
    async def __aexit__(self, exc_type: Optional[type], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> None:
        """Libera el lock automáticamente"""
        
    async def is_locked(self) -> bool:
        """Verifica si el archivo está bloqueado (solo para debugging)"""

from typing import Optional
from src.simple_filelock import FileLock
from src.simple_filelock_async import AsyncFileLock

# Tipado explícito para mejor autocompletado
lockfile_path: str = "/tmp/mi_app.lock"
timeout_segundos: Optional[float] = 5.0
debug_mode: bool = True

# El IDE puede inferir tipos automáticamente
with FileLock(lockfile_path, timeout=timeout_segundos, debug=debug_mode) as lock:
    # lock es de tipo FileLock
    is_locked: bool = lock.is_locked()  # Retorna bool

# Evitar que múltiples instancias de un script se ejecuten simultáneamente
with FileLock("/tmp/mi_script.lock", timeout=0):
    ejecutar_script_unico()

# Múltiples procesos actualizando un archivo de configuración
with FileLock("/tmp/config.lock"):
    config = cargar_configuracion()
    config.update(nuevos_valores)
    guardar_configuracion(config)

# Múltiples scrapers guardando en el mismo archivo de resultados
async with AsyncFileLock("/tmp/resultados.lock"):
    resultados = await cargar_resultados()
    resultados.extend(nuevos_datos)
    await guardar_resultados(resultados)

# Sistema de cola distribuida
with FileLock("/tmp/jobs.lock"):
    job = obtener_proximo_trabajo()
    if job:
        marcar_como_en_proceso(job)

# Habilitar mensajes de debug
with FileLock("/tmp/test.lock", debug=True):
    # Verás mensajes como:
    # 🔒 Intentando adquirir lock en: /tmp/test.lock  
    # ✅ Lock adquirido.
    # 🔓 Lock liberado.
    pass