core_loop.py

# core_loop.py
# Bucle principal de trading MEJORADO.
# Integra:
#   * Red Neuronal Profunda
#   * Análisis multi-timeframe (1M, 2M, 5M, 15M)
#   * 60+ patrones de velas
#   * 15+ indicadores técnicos
#   * 9 estrategias simultáneas con consenso ponderado
#   * Martingale inteligente (limitado)
#   * Memoria persistente de operaciones ganadas/perdidas
#   * Gestión de capital con criterio de Kelly
#   * Retrocesos de Fibonacci
#   * Soportes y resistencias

import time
import numpy as np
import pandas as pd

from conexion_broker import ConexionBroker
from motor_analisis_avanzado import NeuralAnalysisEngine
from estrategias import EstrategiaOpciones
from gestion_riesgo import GestorRiesgo
from indicadores import calcular_todos_los_indicadores
from memoria.base_datos import MemoriaOperaciones
from patrones_velas import DetectorVelasPro
import config


class TradingEngine:
    """
    Motor de trading con Red Neuronal Profunda, Multi-Timeframe, Memoria y Estrategias Avanzadas.
    """

    def __init__(self, credenciales: dict, config_dict: dict, cola_mensajes):
        self.email = credenciales.get('email', '')
        self.password = credenciales.get('password', '')

        tipo_cuenta_raw = credenciales.get('tipo_cuenta', 'Demo')
        self.tipo_cuenta = "PRACTICE" if "Demo" in tipo_cuenta_raw or "Practice" in tipo_cuenta_raw else "REAL"

        self.activo = config_dict.get('activo', 'EURUSD')
        self.timeframe = config_dict.get('timeframe', 60)
        self.duracion_minutos = max(1, self.timeframe // 60)
        self.timeframes_multi = getattr(config, 'TIMEFRAMES_MULTI', [60, 120, 300, 900])

        self.cola_mensajes = cola_mensajes
        self.ejecutando = True
        self.operaciones_ganadas = 0
        self.operaciones_perdidas = 0
        self.saldo_inicial_sesion = 0.0
        self.ultimo_monto_apostado = 0.0
        self.ultima_direccion = None
        self.historial_senales = []  # para análisis posterior

        # Inicializar componentes
        self.broker = ConexionBroker(self.email, self.password, self.tipo_cuenta)
        self.memoria = MemoriaOperaciones(directorio_base="memoria")
        self.gestor_riesgo = None  # se inicializa tras conectar
        self.cerebro_ai = NeuralAnalysisEngine(input_features_dim=60)
        self.estrategia = EstrategiaOpciones(
            payout_broker=config.PROFIT_MINIMO_DEFAULT,
            max_martingale_niveles=config.MAX_MARTINGALE_NIVELES,
            martingale_multiplicador=config.MARTINGALE_MULTIPLICADOR,
        )

        # Cargar memoria persistente
        ejemplos_ganados = self.memoria.cargar_ejemplos_ganados(max_ejemplos=200)
        self.cerebro_ai.cargar_memoria(ejemplos_ganados)
        self.log(f"[MEMORIA] {len(ejemplos_ganados)} ejemplos ganadores cargados")

    def log(self, mensaje: str):
        self.cola_mensajes.put(mensaje)

    def detener(self):
        self.ejecutando = False
        self.log("[SISTEMA] Señal de detención recibida.")

    def _velas_a_dataframe(self, velas):
        if not velas or len(velas) == 0:
            return None
        return pd.DataFrame(velas)

    def _interpretar_senal(self, resultado_ia):
        senal = resultado_ia.get('signal', 'NEUTRAL')
        prob_compra = resultado_ia.get('prob_compra', 0.0)
        prob_venta = resultado_ia.get('prob_venta', 0.0)

        if senal == "COMPRA" and prob_compra > 0.55:
            return "CALL", prob_compra
        if senal == "VENTA" and prob_venta > 0.55:
            return "PUT", prob_venta
        return "NEUTRAL", 0.0

    def _aplicar_estrategias(self, df, resultado_ia, precio_actual):
        """Aplica todas las estrategias y devuelve el consenso."""
        resultados_estrategias = []
        pesos = []

        # 1. Multi-timeframe
        if config.USAR_MULTI_TIMEFRAME and 'multitimeframe' in resultado_ia:
            r = self.estrategia.estrategia_multitimeframe(resultado_ia['multitimeframe'])
            resultados_estrategias.append(r)
            pesos.append(1.5)

        # 2. Patrones de velas
        if config.USAR_PATRONES_VELAS:
            r = self.estrategia.estrategia_patrones_velas(
                resultado_ia.get('patrones_alcistas', []),
                resultado_ia.get('patrones_bajistas', []),
                umbral=config.UMBRAL_PATRONES_MINIMO,
            )
            resultados_estrategias.append(r)
            pesos.append(1.8)

        # 3. Cruce de EMAs
        if config.USAR_CRUCE_EMAS:
            r = self.estrategia.estrategia_cruce_emas(df)
            resultados_estrategias.append(r)
            pesos.append(1.0)

        # 4. Bollinger
        if config.USAR_BANDAS_BOLLINGER:
            r = self.estrategia.estrategia_bollinger(df)
            resultados_estrategias.append(r)
            pesos.append(0.8)

        # 5. RSI + Divergencias
        if config.USAR_DIVERGENCIA_RSI:
            r = self.estrategia.estrategia_rsi(df)
            resultados_estrategias.append(r)
            pesos.append(1.0)

        # 6. Fibonacci
        if config.USAR_FIBONACCI:
            r = self.estrategia.estrategia_fibonacci(df, precio_actual)
            resultados_estrategias.append(r)
            pesos.append(0.9)

        # 7. Soportes y resistencias
        if config.USAR_SOPORTES_RESISTENCIAS:
            r = self.estrategia.estrategia_soportes_resistencias(
                precio_actual,
                resultado_ia.get('soportes', []),
                resultado_ia.get('resistencias', []),
            )
            resultados_estrategias.append(r)
            pesos.append(0.8)

        consenso = self.estrategia.consenso_estrategias(resultados_estrategias, pesos)
        return consenso

    def _procesar_resultado_operacion(self, id_orden, direccion, monto, payout):
        """Espera el resultado, actualiza memoria, gestor de riesgo y retorna el profit."""
        try:
            time.sleep(self.duracion_minutos * 60 + 5)
            resultado = self.broker.verificar_resultado(id_orden)
            if resultado is None:
                self.log("⚠️ [RESULTADO] No se pudo verificar la operación")
                return 0.0, False
            exito = resultado > 0
            return resultado, exito
        except Exception as e:
            self.log(f"❌ [ERROR] Verificando resultado: {e}")
            return 0.0, False

    def _guardar_en_memoria(self, direccion, monto, payout, profit, exito, resultado_ia):
        """Guarda la operación en memoria para aprendizaje futuro."""
        try:
            features = resultado_ia.get('features', None)
            features_list = features.tolist() if isinstance(features, np.ndarray) else features

            indicadores = {
                'rsi': float(resultado_ia.get('patrones_alcistas', []) and 0),
                'confianza_nn': float(resultado_ia.get('confianza_nn', 0)),
                'memoria_boost': float(resultado_ia.get('ram_similarity_score', 0)),
            }
            patrones = (
                [n for n, _ in resultado_ia.get('patrones_alcistas', [])] +
                [n for n, _ in resultado_ia.get('patrones_bajistas', [])]
            )

            self.memoria.registrar_operacion(
                direccion=direccion,
                activo=self.activo,
                monto=monto,
                payout=payout,
                profit=profit,
                exito=exito,
                features=features_list,
                indicadores=indicadores,
                patrones=patrones,
                timeframe=self.timeframe,
                estrategia="consenso_ponderado",
                notas=f"Conf NN: {resultado_ia.get('confianza_nn', 0):.2%}",
            )
        except Exception as e:
            self.log(f"⚠️ [MEMORIA] No se pudo guardar: {e}")

    def ejecutar_bucle_principal(self):
        self.log(f"[SISTEMA] Autenticando usuario {self.email} en IQ Option...")

        exito, mensaje_broker = self.broker.conectar()
        if not exito:
            self.log(f"[ERROR CRÍTICO] {mensaje_broker}")
            self.detener()
            return

        self.log(f"[ÉXITO] {mensaje_broker}")

        balance_actual = self.broker.obtener_balance()
        payout_actual = self.broker.obtener_payout(self.activo)
        self.saldo_inicial_sesion = balance_actual

        self.gestor_riesgo = GestorRiesgo(
            saldo_inicial=balance_actual,
            max_riesgo_operacion=config.MAX_RIESGO_OPERACION,
            max_perdida_diaria=config.MAX_PERDIDA_DIARIA,
            meta_ganancia_diaria=config.META_GANANCIA_DIARIA,
            max_martingale_niveles=config.MAX_MARTINGALE_NIVELES,
        )

        self.log(f"[KPI_SALDO] ${balance_actual:.2f}")
        self.log(f"[KPI_PAYOUT] {payout_actual}%")
        self.log(f"[SISTEMA] Activo: {self.activo} | Timeframe: {self.timeframe}s | Multi-TF: {self.timeframes_multi}")
        self.log(f"[SISTEMA] Red Neuronal Profunda cargada (60+ features, 5 capas ocultas)")

        while self.ejecutando:
            try:
                if not self.gestor_riesgo.puede_operar():
                    self.log(f"⛔ [BLOQUEO] {self.gestor_riesgo.motivo_bloqueo}")
                    self.detener()
                    break

                # 1. Actualizar KPI saldo
                balance = self.broker.obtener_balance()
                self.log(f"[KPI_SALDO] ${balance:.2f}")

                # 2. Leer velas
                velas = self.broker.obtener_velas_recientes(self.activo, self.timeframe, config.VENTANAS_VELAS)
                if not velas or len(velas) < 30:
                    self.log("[MERCADO] Esperando stream de datos...")
                    time.sleep(3)
                    continue

                df = self._velas_a_dataframe(velas)

                # 3. Análisis completo: red neuronal + multi-TF + memoria
                resultado = self.cerebro_ai.analyze(
                    df, simbolo=self.activo, broker=self.broker,
                    usar_multitimeframe=config.USAR_MULTI_TIMEFRAME,
                    timeframes=self.timeframes_multi,
                )

                # 4. Aplicar todas las estrategias y obtener consenso
                precio_actual = float(df['close'].iloc[-1])
                consenso = self._aplicar_estrategias(df, resultado, precio_actual)

                decision_red = resultado.get('signal', 'NEUTRAL')
                prob_compra = resultado['prob_compra']
                prob_venta = resultado['prob_venta']

                # 5. Decisión final
                decision_final = consenso['direccion']
                fuerza_consenso = consenso['fuerza']
                direccion_ia = 'CALL' if decision_red == 'COMPRA' else 'PUT' if decision_red == 'VENTA' else 'NEUTRAL'

                self.log(f"[RED NEURONAL] {self.activo} -> {decision_red} (Conf: {resultado['confianza_nn']:.1%})")
                self.log(f"[ESTRATEGIAS] Consenso: {decision_final} (Fuerza: {fuerza_consenso:.1%}) | {consenso['motivo'][:120]}")
                self.log(f"[IA_DETALLE] CALL: {prob_compra:.1%} | PUT: {prob_venta:.1%} | "
                         f"Memoria: {resultado['ram_similarity_score']:.2f}")

                if resultado.get('patrones_alcistas'):
                    mejor_alc = max(resultado['patrones_alcistas'], key=lambda x: x[1])
                    self.log(f"[PATRON ↑] {mejor_alc[0]} ({mejor_alc[1]:.0%})")
                if resultado.get('patrones_bajistas'):
                    mejor_baj = max(resultado['patrones_bajistas'], key=lambda x: x[1])
                    self.log(f"[PATRON ↓] {mejor_baj[0]} ({mejor_baj[1]:.0%})")

                # Guardar historial
                self.historial_senales.append({
                    'timestamp': time.time(),
                    'direccion_ia': direccion_ia,
                    'consenso': decision_final,
                    'fuerza': fuerza_consenso,
                })

                # 6. Ejecutar si consenso es claro
                if decision_final in ('CALL', 'PUT') and fuerza_consenso >= 0.50:
                    # Calcular monto con criterio de Kelly/adaptativo
                    monto = self.gestor_riesgo.calcular_monto_entrada(
                        fuerza_senal=fuerza_consenso,
                        usar_kelly=True,
                        win_rate=(self.operaciones_ganadas / max(self.operaciones_ganadas + self.operaciones_perdidas, 1)),
                    )
                    self.ultimo_monto_apostado = monto

                    # Martingale inteligente
                    if config.USAR_MARTINGALE_INTELIGENTE and self.ultima_direccion == decision_final:
                        # Verificar si la anterior fue perdida
                        if self.gestor_riesgo.operaciones_perdidas_consecutivas > 0:
                            mg = self.estrategia.aplicar_martingale(
                                perdida_actual=True,
                                direccion_anterior=self.ultima_direccion,
                                senal_actual=decision_final,
                            )
                            if mg and mg.get('aplicar'):
                                monto_base = monto
                                monto = round(monto * mg.get('multiplicador', 1.0), 2)
                                self.log(f"[MARTINGALE] {mg.get('motivo', 'N/A')}: ${monto_base:.2f} → ${monto:.2f}")

                    # Enviar orden
                    if decision_final == 'CALL':
                        self.log(f"🟢 [EJECUCIÓN] CALL en {self.activo} por ${monto:.2f} ({fuerza_consenso:.0%} confianza)")
                        id_orden = self.broker.enviar_orden_compra(
                            simbolo=self.activo,
                            volumen=monto,
                            duracion=self.duracion_minutos,
                        )
                    else:
                        self.log(f"🔴 [EJECUCIÓN] PUT en {self.activo} por ${monto:.2f} ({fuerza_consenso:.0%} confianza)")
                        id_orden = self.broker.enviar_orden_venta(
                            simbolo=self.activo,
                            volumen=monto,
                            duracion=self.duracion_minutos,
                        )

                    if id_orden:
                        profit, exito = self._procesar_resultado_operacion(
                            id_orden, decision_final, monto, payout_actual
                        )
                        if exito:
                            self.operaciones_ganadas += 1
                            self.log(f"✅ [RESULTADO] {decision_final} GANADA | Profit: ${profit:.2f}")
                        else:
                            self.operaciones_perdidas += 1
                            self.log(f"❌ [RESULTADO] {decision_final} PERDIDA | Pérdida: ${abs(profit):.2f}")

                        # Actualizar gestor de riesgo
                        self.gestor_riesgo.registrar_resultado(profit)

                        # Guardar en memoria (¡lo que aprende el bot!)
                        self._guardar_en_memoria(
                            decision_final, monto, payout_actual / 100.0,
                            profit, exito, resultado
                        )

                        # Recargar memoria de ganadas (actualización dinámica)
                        nuevos_ganados = self.memoria.cargar_ejemplos_ganados(max_ejemplos=200)
                        self.cerebro_ai.cargar_memoria(nuevos_ganados)

                        self.ultima_direccion = decision_final
                    else:
                        self.log(f"⚠️ [ERROR] No se pudo enviar la orden")
                else:
                    self.log(f"[MERCADO] Sin señal clara (fuerza={fuerza_consenso:.0%}). Esperando...")

                # KPIs
                self.log(f"[KPI_OPS] {self.operaciones_ganadas}G / {self.operaciones_perdidas}P")
                stats = self.gestor_riesgo.obtener_estadisticas()
                self.log(f"[KPI_WINRATE] {stats['win_rate']:.1%} | Drawdown: {stats['drawdown_actual']:.1%}")

                time.sleep(3)

            except Exception as e:
                self.log(f"[EXCEPCIÓN] {str(e)}")
                time.sleep(3)

        # Cierre limpio
        self.broker.desconectar()
        self.log("[SISTEMA] Motor de trading apagado. Conexión cerrada.")
        self.log(f"[RESUMEN] G:{self.operaciones_ganadas} | P:{self.operaciones_perdidas} | "
                 f"WR:{self.operaciones_ganadas / max(self.operaciones_ganadas + self.operaciones_perdidas, 1):.1%}")