"""
run_analysis.py - Ejecuta análisis en proceso separado para no bloquear webhook
"""
import sys
import os
import json
import asyncio
import logging
import random

# Agregar directorio al path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from config import TELEGRAM_TOKEN, SUPPORT_URL
from db import is_subscription_active
from market_analysis import analyze_multiple_symbols
from indicators import calculate_all_indicators
from premium_signals import get_premium_recommendations
from recommendations import get_top_recommendations, format_premium_signal_message, format_recommendations_message

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def send_telegram_request(method: str, payload: dict):
    """Envía petición a Telegram API"""
    import requests
    api_url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/{method}"
    
    try:
        response = requests.post(api_url, json=payload, timeout=15)
        return response.json()
    except Exception as e:
        logger.error(f"Error enviando {method}: {e}")
        return None


async def run_analysis(market_type: str, symbols: list = None, top_n: int = 3, use_premium: bool = True):
    """Ejecuta análisis técnico PREMIUM"""
    from config import get_symbols_list
    
    if symbols is None:
        symbols = get_symbols_list()
    
    # Muestrear automáticamente si hay muchas monedas (reemplaza a randomize)
    if len(symbols) > 20:
        symbols_to_analyze = random.sample(symbols, min(20, len(symbols)))
    else:
        symbols_to_analyze = symbols
    
    # Obtener datos CON CACHÉ
    market_data = await analyze_multiple_symbols(
        symbols=symbols_to_analyze, 
        market_type=market_type, 
        max_concurrent=3,
        use_cache=True
    )
    
    # Filtrar datos válidos
    valid_data = {k: v for k, v in market_data.items() if v is not None and not v.empty}
    
    # Calcular indicadores
    for symbol, df in valid_data.items():
        valid_data[symbol] = calculate_all_indicators(df)
    
    # Obtener recomendaciones
    if use_premium:
        recommendations = get_premium_recommendations(
            market_data=valid_data, 
            market_type=market_type, 
            min_score=50,  # Umbral ajustado para pruebas (65%)
            top_n=top_n
        )
    else:
        # Fallback al sistema antiguo
        recommendations = get_top_recommendations(
            market_data=valid_data, 
            market_type=market_type, 
            top_n=top_n
        )
    
    return recommendations


def main():
    """Función principal ejecutada en proceso separado"""
    if len(sys.argv) < 2:
        logger.error("No se proporcionó archivo de parámetros")
        sys.exit(1)
    
    temp_file = sys.argv[1]
    
    try:
        # Leer parámetros
        with open(temp_file, 'r', encoding='utf-8') as f:
            params = json.load(f)
        
        user_id = params['user_id']
        data = params['data']
        message_id = params['message_id']
        
        logger.info(f"🔍 Iniciando análisis para user {user_id}, tipo: {data}")
        
        # Verificar suscripción
        if not is_subscription_active(user_id):
            send_telegram_request('editMessageText', {
                'chat_id': user_id,
                'message_id': message_id,
                'text': "🔒 <b>Acceso Restringido</b>\n\nTu suscripción expiró o no está activa.",
                'parse_mode': 'HTML'
            })
            os.remove(temp_file)
            sys.exit(0)
        
        # Ejecutar análisis (CORREGIDO: sin argumento 'randomize')
        if data == 'analyze_spot':
            coro = run_analysis(market_type='spot', top_n=3)
            market_label = 'Spot'
        elif data == 'analyze_futures':
            coro = run_analysis(market_type='swap', top_n=3)
            market_label = 'Futuros'
        else:  # analyze_top6
            coro = run_analysis(
                market_type='spot', 
                symbols=['BTC/USDT', 'ETH/USDT', 'BNB/USDT', 'SOL/USDT', 'XRP/USDT', 'ADA/USDT'], 
                top_n=3
            )
            market_label = 'Top 6'
        
        # Ejecutar event loop
        try:
            loop = asyncio.get_event_loop()
        except RuntimeError:
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
        
        recommendations = loop.run_until_complete(coro)
        
        # Formatear mensaje (Usar formato premium si hay datos, sino el normal)
        if recommendations and len(recommendations) > 0:
            # Verificamos si es formato premium (tiene 'score') o normal (tiene 'action')
            if 'score' in recommendations[0]:
                message = format_premium_signal_message(recommendations, market_label)
            else:
                message = format_recommendations_message(recommendations, market_label)
        else:
            message = "⚠️ <b>No se encontraron oportunidades de alta confianza</b>\n\n" \
                      "El mercado está lateral o sin señales claras en este momento.\n" \
                      "💡 <i>Intenta nuevamente en 15-30 minutos.</i>"
        
        # Botones
        keyboard = {
            'inline_keyboard': [
                [{'text': '🔄 Nuevo Spot', 'callback_data': 'analyze_spot'}, 
                 {'text': '🔄 Nuevo Futuros', 'callback_data': 'analyze_futures'}],
                [{'text': '🏆 Top 6', 'callback_data': 'analyze_top6'}], 
                [{'text': '💬 Soporte', 'url': SUPPORT_URL}]
            ]
        }
        
        # Enviar resultado
        send_telegram_request('editMessageText', {
            'chat_id': user_id,
            'message_id': message_id,
            'text': message,
            'reply_markup': keyboard,
            'parse_mode': 'HTML',
            'disable_web_page_preview': True
        })
        
        logger.info(f"✅ Análisis completado para user {user_id}")
        
    except Exception as e:
        logger.error(f"❌ Error en análisis background: {e}", exc_info=True)
        
        # Intentar notificar error
        try:
            send_telegram_request('editMessageText', {
                'chat_id': user_id,
                'message_id': message_id,
                'text': "❌ <b>Error en el análisis</b>\n\nIntenta nuevamente en 1-2 minutos.",
                'parse_mode': 'HTML'
            })
        except:
            pass
    
    finally:
        # Limpiar archivo temporal
        try:
            if os.path.exists(temp_file):
                os.remove(temp_file)
        except:
            pass


if __name__ == "__main__":
    main()