#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Rate Update Script

Este script actualiza las tarifas por hora de diferentes tipos de programadores
por región utilizando la API de Perplexity para obtener datos actualizados.

Licencia: AGPL-3.0
Modified: 2025-03-12
"""

import os
import glob
import re
import json
import logging
import requests
import sys
import subprocess
import importlib.util
import time
from pathlib import Path

# Configuración de logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.StreamHandler()]
)
logger = logging.getLogger('rate_update')

# Verificar si pycountry está instalado, si no, instalarlo
def check_install_pycountry():
    """Verifica si pycountry está instalado y lo instala si es necesario."""
    if importlib.util.find_spec("pycountry") is None:
        logger.info("La biblioteca pycountry no está instalada.")
        
        # Verificar si pip está disponible
        try:
            # Primero comprobamos si pip está instalado
            pip_check = subprocess.run([sys.executable, "-m", "pip", "--version"], 
                                      stdout=subprocess.PIPE, 
                                      stderr=subprocess.PIPE)
            
            if pip_check.returncode == 0:
                logger.warning("La biblioteca pycountry no está instalada.")
                logger.warning("Se continuará sin validación de códigos de país.")
                logger.warning("Para habilitar la validación, instale pycountry manualmente:")
                logger.warning("    sudo pip3 install pycountry")
                logger.warning("O:")
                logger.warning("    sudo apt-get install python3-pycountry")
                return False
            else:
                logger.warning("pip no está instalado. No se puede instalar pycountry automáticamente.")
                logger.warning("Se continuará sin validación de códigos de país.")
                logger.warning("Para habilitar la validación, instale pycountry manualmente:")
                logger.warning("    sudo apt-get install python3-pip")
                logger.warning("    sudo pip3 install pycountry")
                logger.warning("O:")
                logger.warning("    sudo apt-get install python3-pycountry")
                return False
                
        except FileNotFoundError:
            logger.warning("No se pudo ejecutar pip. El sistema no puede encontrar el ejecutable de Python.")
            logger.warning("Se continuará sin validación de códigos de país.")
            logger.warning("Para habilitar la validación, verifique su instalación de Python y pycountry.")
            return False
    
    # Intentamos importar pycountry
    try:
        global pycountry
        import pycountry
        return True
    except ImportError:
        logger.warning("No se puede importar pycountry. Continuando sin validación de códigos de país.")
        return False

# Directorio base del proyecto
BASE_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
CONFIG_DIR = BASE_DIR / 'bin' / 'config'

# Archivo de configuración para el modelo de IA
MODEL_CONFIG_FILE = CONFIG_DIR / 'rate_model.ai'

def get_ai_model():
    """Obtener el modelo de IA configurado."""
    try:
        with open(MODEL_CONFIG_FILE, 'r', encoding='utf-8') as f:
            model = f.read().strip()
            # Si hay un valor específico configurado, usarlo
            if model and model.strip():
                return model
    except FileNotFoundError:
        logger.warning(f"Archivo de configuración {MODEL_CONFIG_FILE} no encontrado. Usando modelo predeterminado 'sonar'.")
    
    # Usar 'sonar' como modelo predeterminado (el más adecuado para la API de Perplexity)
    return "sonar"

def get_perplexity_api_key():
    """Obtener la clave API de Perplexity desde una variable de entorno o archivo."""
    # Intentar obtener la clave de la variable de entorno
    api_key = os.environ.get('PERPLEXITY_API_KEY')
    
    # Si no está en la variable de entorno, intentar cargarla desde un archivo
    if not api_key:
        # Rutas posibles para el archivo de API key
        possible_paths = [
            os.path.expanduser('~/.perplexity/api_key'),
            os.path.expanduser('~/.config/perplexity/api_key'),
            os.path.join(BASE_DIR, 'bin', 'config', 'perplexity_api_key')
        ]
        
        for path in possible_paths:
            try:
                if os.path.exists(path):
                    logger.info(f"Intentando cargar API key desde: {path}")
                    with open(path, 'r', encoding='utf-8') as f:
                        api_key = f.read().strip()
                        if api_key:
                            logger.info("API key de Perplexity cargada desde archivo.")
                            break
            except Exception as e:
                logger.warning(f"Error al leer el archivo de API key {path}: {e}")
                continue
    
    # Si seguimos sin tener API key, mostrar error y salir
    if not api_key:
        logger.error("No se encontró la clave API de Perplexity.")
        logger.error("Opciones para configurarla:")
        logger.error("1. Establecer la variable de entorno PERPLEXITY_API_KEY")
        logger.error("2. Crear un archivo ~/.perplexity/api_key con la clave")
        logger.error("3. Crear un archivo ~/.config/perplexity/api_key con la clave")
        logger.error("4. Crear un archivo bin/config/perplexity_api_key en el directorio del proyecto")
        sys.exit(1)
        
    # Validar formato básico de la API key
    if not api_key.startswith('pplx-'):
        logger.warning("El formato de la API key de Perplexity parece incorrecto.")
        logger.warning("Las API keys de Perplexity suelen comenzar con 'pplx-'.")
        
    return api_key

def query_perplexity(prompt, model="o1"):
    """Realizar una consulta a la API de Perplexity."""
    api_key = get_perplexity_api_key()
    
    url = "https://api.perplexity.ai/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    # Verificar los modelos disponibles en Perplexity - 2025
    # Modelos válidos: sonar, mistral-7b, llama-3-sonar-small, llama-3-sonar-medium, llama-3-70b, mixtral-8x7b, codellama-70b
    # Usamos el modelo 'sonar' de Perplexity para mejor compatibilidad y resultados
        
    data = {
        "model": model,
        "messages": [
            {
                "role": "system",
                "content": "You are a helpful assistant that provides accurate salary information for developers worldwide. Respond only with numeric values in USD with 2 decimal places."
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        "max_tokens": 100
    }
    
    try:
        logger.info(f"Enviando consulta a Perplexity usando modelo: {model}")
        logger.info(f"Prompt: {prompt}")
        
        # Convertir el diccionario a JSON para obtener la representación exacta que se enviará
        request_body = json.dumps(data, indent=2)
        logger.info(f"Cuerpo de la solicitud: {request_body}")
        
        response = requests.post(url, headers=headers, json=data)
        
        # Mostrar información de respuesta
        logger.info(f"Código de estado HTTP: {response.status_code}")
        logger.info(f"Respuesta (raw): {response.text[:200]}...")  # Mostrar los primeros 200 caracteres
        
        # Si la respuesta no es 200, mostrar el error completo
        if response.status_code != 200:
            logger.error(f"Error de API Perplexity ({response.status_code}): {response.text}")
            # Intentar analizar el error para obtener más información
            try:
                error_data = response.json()
                error_message = error_data.get("error", {}).get("message", "Mensaje de error no disponible")
                logger.error(f"Mensaje de error: {error_message}")
            except:
                pass
            return None
        
        # Continuar si la respuesta es exitosa
        result = response.json()
        
        # Extraer solo el valor numérico de la respuesta
        content = result.get('choices', [{}])[0].get('message', {}).get('content', '')
        logger.info(f"Contenido de la respuesta: {content}")
        
        # Estrategia 1: Buscar patrones específicos de dinero (con y sin símbolo de dólar)
        # Buscar un patrón como $30.00, 30.00, $30, o 30 USD
        money_patterns = [
            r'\$(\d+\.\d{2})',          # $30.00
            r'(\d+\.\d{2})\s*USD',      # 30.00 USD
            r'(\d+\.\d{2})',            # 30.00
            r'\$(\d+)',                 # $30
            r'(\d+)\s*USD',             # 30 USD
            r'(\d+(?:\.\d+)?)'          # Cualquier número con o sin decimales
        ]
        
        for pattern in money_patterns:
            match = re.search(pattern, content)
            if match:
                try:
                    value = float(match.group(1))
                    logger.info(f"Valor extraído con patrón {pattern}: {value}")
                    return round(value, 2)  # Asegurar 2 decimales
                except (ValueError, IndexError):
                    continue
        
        # Estrategia 2: Extraer todos los números y elegir el más probable
        all_numbers = re.findall(r'\d+(?:\.\d+)?', content)
        if all_numbers:
            try:
                # Si hay varios números, elegir el más probable
                # (En este caso, podríamos tomar el promedio o el primero)
                if len(all_numbers) > 1:
                    logger.info(f"Múltiples números encontrados: {all_numbers}")
                    # Eliminamos valores extremadamente altos o bajos
                    filtered_numbers = [float(n) for n in all_numbers if 5 <= float(n) <= 500]
                    if filtered_numbers:
                        value = sum(filtered_numbers) / len(filtered_numbers)
                    else:
                        value = float(all_numbers[0])
                else:
                    value = float(all_numbers[0])
                    
                logger.info(f"Valor final extraído: {value}")
                return round(value, 2)
            except ValueError:
                pass
        
        # Estrategia 3: Último recurso, intentar limpiar el texto y extraer un número
        try:
            # Eliminar cualquier símbolo de moneda y espacios
            cleaned_content = re.sub(r'[^\d.]', '', content)
            if cleaned_content:
                value = round(float(cleaned_content), 2)
                logger.info(f"Valor limpiado y extraído: {value}")
                return value
        except ValueError:
            pass
            
        logger.error(f"No se pudo extraer un valor numérico de la respuesta: {content}")
        return None
            
    except requests.exceptions.RequestException as e:
        logger.error(f"Error al conectar con la API de Perplexity: {e}")
        return None
    except Exception as e:
        logger.error(f"Error inesperado en la consulta a Perplexity: {e}")
        return None

# Variable global para indicar si pycountry está disponible
pycountry_available = False

def is_valid_country_code(code):
    """
    Verifica si un código de país de 2 letras es válido.
    Usa pycountry si está disponible, o una lista básica de códigos comunes.
    También acepta códigos especiales 'ww' y 'la'.
    """
    # Códigos especiales para propósitos internos
    if code in ['ww', 'la']:  # worldwide y Latin America
        return True
    
    # Lista básica de códigos de país comunes (ISO 3166-1 alpha-2)
    common_country_codes = [
        'af', 'al', 'dz', 'as', 'ad', 'ao', 'ai', 'aq', 'ag', 'ar', 
        'am', 'aw', 'au', 'at', 'az', 'bs', 'bh', 'bd', 'bb', 'by', 
        'be', 'bz', 'bj', 'bm', 'bt', 'bo', 'ba', 'bw', 'br', 'bn', 
        'bg', 'bf', 'bi', 'cv', 'kh', 'cm', 'ca', 'ky', 'cf', 'td', 
        'cl', 'cn', 'co', 'km', 'cg', 'cd', 'ck', 'cr', 'ci', 'hr', 
        'cu', 'cy', 'cz', 'dk', 'dj', 'dm', 'do', 'ec', 'eg', 'sv', 
        'gq', 'er', 'ee', 'et', 'fk', 'fo', 'fj', 'fi', 'fr', 'gf', 
        'pf', 'ga', 'gm', 'ge', 'de', 'gh', 'gi', 'gr', 'gl', 'gd', 
        'gp', 'gu', 'gt', 'gn', 'gw', 'gy', 'ht', 'va', 'hn', 'hk', 
        'hu', 'is', 'in', 'id', 'ir', 'iq', 'ie', 'il', 'it', 'jm', 
        'jp', 'jo', 'kz', 'ke', 'ki', 'kp', 'kr', 'kw', 'kg', 'la', 
        'lv', 'lb', 'ls', 'lr', 'ly', 'li', 'lt', 'lu', 'mo', 'mk', 
        'mg', 'mw', 'my', 'mv', 'ml', 'mt', 'mh', 'mq', 'mr', 'mu', 
        'yt', 'mx', 'fm', 'md', 'mc', 'mn', 'me', 'ms', 'ma', 'mz', 
        'mm', 'na', 'nr', 'np', 'nl', 'nc', 'nz', 'ni', 'ne', 'ng', 
        'nu', 'nf', 'mp', 'no', 'om', 'pk', 'pw', 'ps', 'pa', 'pg', 
        'py', 'pe', 'ph', 'pn', 'pl', 'pt', 'pr', 'qa', 're', 'ro', 
        'ru', 'rw', 'bl', 'sh', 'kn', 'lc', 'mf', 'pm', 'vc', 'ws', 
        'sm', 'st', 'sa', 'sn', 'rs', 'sc', 'sl', 'sg', 'sx', 'sk', 
        'si', 'sb', 'so', 'za', 'gs', 'ss', 'es', 'lk', 'sd', 'sr', 
        'sj', 'sz', 'se', 'ch', 'sy', 'tw', 'tj', 'tz', 'th', 'tl', 
        'tg', 'tk', 'to', 'tt', 'tn', 'tr', 'tm', 'tc', 'tv', 'ug', 
        'ua', 'ae', 'gb', 'us', 'uy', 'uz', 'vu', 've', 'vn', 'vg', 
        'vi', 'wf', 'eh', 'ye', 'zm', 'zw'
    ]
    
    # Si pycountry está disponible, lo usamos para validación
    global pycountry_available
    if pycountry_available:
        try:
            # Verifica si el código existe en pycountry
            return pycountry.countries.get(alpha_2=code.upper()) is not None
        except (AttributeError, Exception) as e:
            logger.warning(f"Error al validar el código de país '{code}' con pycountry: {e}")
            # Fallback a la lista básica
    
    # Si pycountry no está disponible o falló, usamos la lista básica
    return code.lower() in common_country_codes

def parse_rate_filename(filename):
    """
    Analiza el nombre del archivo de tarifa para extraer el tipo de programador y la región.
    Formato: [tipo_de_programador]_[código_país].rate
    Valida el código de país usando pycountry.
    """
    base_name = os.path.basename(filename)
    match = re.match(r'([a-z]+)_([a-z]{2})\.rate$', base_name)
    
    if not match:
        # Para archivos como kdevs.rate que no siguen el patrón estándar
        if base_name.endswith('.rate'):
            programmer_type = base_name.replace('.rate', '')
            return programmer_type, None
        return None, None
    
    programmer_type, region_code = match.groups()
    
    # Validar el código de país
    if not is_valid_country_code(region_code):
        logger.warning(f"Código de país no válido '{region_code}' en el archivo {base_name}")
        # Aun así continuamos con el proceso
    
    return programmer_type, region_code

def generate_prompt(programmer_type, region_code):
    """Genera un prompt para consultar a Perplexity sobre la tarifa horaria."""
    region_map = {
        'ww': 'mundial',
        'la': 'Latinoamérica',
        'pa': 'Panamá',
        'co': 'Colombia',
        'mx': 'México',
        'ar': 'Argentina',
        'br': 'Brasil',
        'cl': 'Chile',
        'pe': 'Perú',
        'ec': 'Ecuador',
        'us': 'Estados Unidos',
        'ca': 'Canadá',
        'uk': 'Reino Unido',
        'de': 'Alemania',
        'fr': 'Francia',
        'es': 'España',
        'it': 'Italia'
    }
    
    # Archivos especiales como kdevs.rate se manejan de forma diferente
    if programmer_type == 'kdevs':
        # Simplemente mantener el valor actual para kdevs.rate
        return None
    
    programmer_map = {
        'bash': 'programador de scripts Bash/Shell',
        'python': 'desarrollador Python',
        'fullstack': 'desarrollador Full Stack',
        'frontend': 'desarrollador Frontend',
        'backend': 'desarrollador Backend',
        'devops': 'ingeniero DevOps',
        'mobile': 'desarrollador de aplicaciones móviles',
        'java': 'desarrollador Java',
        'php': 'desarrollador PHP',
        'ruby': 'desarrollador Ruby',
        'dotnet': 'desarrollador .NET',
        'data': 'científico de datos',
        'ml': 'ingeniero de Machine Learning',
        'cloud': 'arquitecto Cloud',
        'odoo': 'desarrollador Odoo'
    }
    
    region_name = region_map.get(region_code, f'región con código {region_code}')
    programmer_description = programmer_map.get(programmer_type, f'desarrollador {programmer_type}')
    
    # Usamos el año actual para la consulta principal
    current_year = time.strftime("%Y")
    prompt = f"¿Cuál es la tarifa por hora promedio en dólares estadounidenses (USD) para un {programmer_description} en {region_name} en {current_year}? Si no tienes datos del {current_year}, usa la información más reciente y haz una estimación aproximada. Responde solo con el valor numérico con dos decimales."
    
    return prompt

def get_fallback_rate(programmer_type, region_code):
    """
    Proporciona una tarifa de respaldo cuando la API falla o no está disponible.
    Usa estimaciones basadas en datos de mercado generales.
    """
    # Tarifas base por tipo de programador (valores estimados en USD)
    base_rates = {
        'bash': 25.00,
        'python': 35.00,
        'fullstack': 45.00,
        'frontend': 40.00,
        'backend': 42.00,
        'devops': 50.00,
        'mobile': 45.00,
        'java': 40.00,
        'php': 30.00,
        'ruby': 40.00,
        'dotnet': 45.00,
        'data': 55.00,
        'ml': 65.00,
        'cloud': 60.00,
        'odoo': 40.00
    }
    
    # Valor por defecto si el tipo no está en la lista
    base_rate = base_rates.get(programmer_type, 35.00)
    
    # Factores de ajuste por región
    region_factors = {
        'ww': 1.0,    # Promedio mundial
        'la': 0.7,    # Latinoamérica
        'pa': 0.75,   # Panamá
        'co': 0.65,   # Colombia
        'mx': 0.7,    # México
        'ar': 0.6,    # Argentina
        'br': 0.7,    # Brasil
        'cl': 0.75,   # Chile
        'pe': 0.6,    # Perú
        'ec': 0.6,    # Ecuador
        'us': 1.8,    # Estados Unidos
        'ca': 1.6,    # Canadá
        'uk': 1.5,    # Reino Unido
        'de': 1.6,    # Alemania
        'fr': 1.5,    # Francia
        'es': 1.3,    # España
        'it': 1.3     # Italia
    }
    
    # Si no hay región, devolver la tarifa base
    if region_code is None:
        return base_rate
        
    # Aplicar factor regional
    factor = region_factors.get(region_code, 1.0)
    adjusted_rate = base_rate * factor
    
    return round(adjusted_rate, 2)

def update_rate_files():
    """Actualiza los archivos de tarifas con datos de Perplexity."""
    # Obtener modelo configurado
    model = get_ai_model()
    logger.info(f"Usando modelo de IA: {model}")
    
    # Verificar disponibilidad de la API
    api_available = True
    try:
        # Intentar obtener la clave API (si falla, saltará una excepción)
        get_perplexity_api_key()
    except:
        api_available = False
        logger.warning("API de Perplexity no disponible. Se usarán valores de respaldo.")
    
    # Buscar todos los archivos .rate
    rate_files = glob.glob(str(CONFIG_DIR / '*.rate'))
    logger.info(f"Encontrados {len(rate_files)} archivos de tarifas para actualizar.")
    
    # Control de errores para limitar los intentos de API
    consecutive_errors = 0
    max_consecutive_errors = 3
    
    for rate_file in rate_files:
        # Si hemos tenido demasiados errores consecutivos, cambiar a modo de respaldo
        if consecutive_errors >= max_consecutive_errors:
            logger.error(f"Se detectaron {consecutive_errors} errores consecutivos. Cambiando a modo de respaldo.")
            api_available = False
            
        programmer_type, region_code = parse_rate_filename(rate_file)
        
        if programmer_type is None:
            logger.warning(f"No se pudo analizar el nombre del archivo: {rate_file}, saltando.")
            continue
        
        # Si es un archivo especial como kdevs.rate
        if region_code is None:
            prompt = generate_prompt(programmer_type, None)
            # Saltamos los archivos especiales que no necesitan actualización
            if prompt is None:
                logger.info(f"Saltando archivo especial: {os.path.basename(rate_file)}")
                continue
        else:
            prompt = generate_prompt(programmer_type, region_code)
        
        # Variable para almacenar la tarifa
        rate = None
        
        # Si la API está disponible, intentar consultarla
        if api_available:
            logger.info(f"Consultando tarifa para {programmer_type}" + 
                       (f" en región {region_code}" if region_code else ""))
            
            try:
                # Consultar a Perplexity
                rate = query_perplexity(prompt, model)
                
                if rate is not None:
                    consecutive_errors = 0  # Reiniciar contador de errores tras un éxito
                else:
                    logger.error(f"No se pudo obtener la tarifa para {programmer_type}" + 
                                (f" en región {region_code}" if region_code else ""))
                    consecutive_errors += 1
            except Exception as e:
                logger.error(f"Error al actualizar {os.path.basename(rate_file)}: {e}")
                consecutive_errors += 1
                # Pequeña pausa tras un error para evitar sobrecargar la API
                time.sleep(2)
        
        # Si la API falló o no está disponible, usar valor de respaldo
        if rate is None:
            logger.warning(f"Usando valor de respaldo para {programmer_type}" + 
                          (f" en región {region_code}" if region_code else ""))
            rate = get_fallback_rate(programmer_type, region_code)
            logger.info(f"Valor de respaldo generado: {rate:.2f}")
        
        # Guardar el resultado en el archivo - solo el valor numérico con dos decimales, sin salto de línea
        with open(rate_file, 'w', encoding='utf-8') as f:
            f.write(f"{rate:.2f}")
        logger.info(f"Actualizado {os.path.basename(rate_file)} con valor: {rate:.2f}")

if __name__ == "__main__":
    
    logger.info("Iniciando actualización de tarifas...")
    
    # Verificar e instalar pycountry si es necesario
    pycountry_available = check_install_pycountry()
    
    # Actualizar la variable global
    globals()['pycountry_available'] = pycountry_available
    
    # Mostrar estado de validación de países
    if pycountry_available:
        logger.info("Validación de códigos de país habilitada con pycountry.")
    else:
        logger.info("Usando lista interna para validación básica de códigos de país.")
    
    # Actualizar los archivos de tarifas
    update_rate_files()
    
    logger.info("Proceso de actualización de tarifas completado.")