#!/usr/bin/env python3
"""
Script para ejecutar el cron de procesamiento de comandos pendientes
mediante curl y requests como fallback.
"""

import subprocess
import requests
import logging
import sys
import time
from datetime import datetime

# Configuración
URL = "https://gps.divisiongps.com.ar/index.php?r=cron/procesarComandosPendientes"
TIMEOUT = 30  # segundos
LOG_FORMAT = '%(asctime)s %(levelname)s: %(message)s'

# Configurar logging
logging.basicConfig(level=logging.INFO, format=LOG_FORMAT, stream=sys.stdout)
logger = logging.getLogger('cron_executor')

def ejecutar_con_curl():
    """
    Ejecuta la URL usando curl mediante subprocess.
    """
    try:
        logger.info("Ejecutando URL con curl...")
        
        # Comando curl con opciones
        comando_curl = [
            'curl',
            '-X', 'GET',
            '-L',  # Seguir redirects
            '--connect-timeout', str(TIMEOUT),
            '--max-time', str(TIMEOUT * 2),
            '--user-agent', 'CronExecutor/1.0 (Python)',
            '--silent',  # No mostrar barra de progreso
            '--show-error',  # Mostrar errores
            '--fail',  # Fallar en códigos HTTP de error
            URL
        ]
        
        logger.info(f"Comando: {' '.join(comando_curl)}")
        
        # Ejecutar curl
        start_time = time.time()
        result = subprocess.run(
            comando_curl,
            capture_output=True,
            text=True,
            timeout=TIMEOUT * 2
        )
        
        duration = time.time() - start_time
        
        if result.returncode == 0:
            logger.info(f"✅ Curl ejecutado exitosamente en {duration:.2f}s")
            logger.info(f"Respuesta HTTP recibida ({len(result.stdout)} caracteres)")
            if result.stdout.strip():
                logger.info(f"Contenido: {result.stdout[:200]}{'...' if len(result.stdout) > 200 else ''}")
            return True, result.stdout
        else:
            logger.error(f"❌ Error en curl (código: {result.returncode})")
            logger.error(f"Error: {result.stderr}")
            return False, result.stderr
            
    except subprocess.TimeoutExpired:
        logger.error(f"❌ Timeout ejecutando curl después de {TIMEOUT * 2}s")
        return False, "Timeout"
    except FileNotFoundError:
        logger.error("❌ curl no encontrado en el sistema")
        return False, "curl no encontrado"
    except Exception as e:
        logger.error(f"❌ Error inesperado con curl: {e}")
        return False, str(e)

def ejecutar_con_requests():
    """
    Ejecuta la URL usando la librería requests como fallback.
    """
    try:
        logger.info("Ejecutando URL con requests...")
        
        headers = {
            'User-Agent': 'CronExecutor/1.0 (Python/requests)'
        }
        
        start_time = time.time()
        response = requests.get(
            URL,
            headers=headers,
            timeout=TIMEOUT,
            allow_redirects=True
        )
        
        duration = time.time() - start_time
        
        # Verificar código de respuesta
        response.raise_for_status()
        
        logger.info(f"✅ Requests ejecutado exitosamente en {duration:.2f}s")
        logger.info(f"Código HTTP: {response.status_code}")
        logger.info(f"Respuesta recibida ({len(response.text)} caracteres)")
        
        if response.text.strip():
            logger.info(f"Contenido: {response.text[:200]}{'...' if len(response.text) > 200 else ''}")
            
        return True, response.text
        
    except requests.exceptions.Timeout:
        logger.error(f"❌ Timeout con requests después de {TIMEOUT}s")
        return False, "Timeout"
    except requests.exceptions.RequestException as e:
        logger.error(f"❌ Error con requests: {e}")
        return False, str(e)
    except Exception as e:
        logger.error(f"❌ Error inesperado con requests: {e}")
        return False, str(e)

def main():
    """
    Función principal que ejecuta la URL.
    Intenta primero con curl, si falla usa requests.
    """
    logger.info("=== EJECUTOR DE CRON - COMANDOS PENDIENTES ===")
    logger.info(f"URL: {URL}")
    logger.info(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    
    # Intentar con curl primero
    success, result = ejecutar_con_curl()
    
    if not success:
        logger.warning("Curl falló, intentando con requests como fallback...")
        success, result = ejecutar_con_requests()
    
    if success:
        logger.info("=== EJECUCIÓN COMPLETADA EXITOSAMENTE ===")
        return 0
    else:
        logger.error("=== EJECUCIÓN FALLÓ ===")
        logger.error(f"Último error: {result}")
        return 1

if __name__ == '__main__':
    exit_code = main()
    sys.exit(exit_code)