monitor.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ProfitDLL - Monitor de Trades por Corretora
Exemplo de uso da ProfitDLL para monitorar trades agressores por corretora
"""

import ctypes
from ctypes import *
import time
from datetime import datetime, timedelta
from threading import Lock
from collections import defaultdict
import json
import csv
import os
from pathlib import Path

# ============================================================================
# SISTEMA AVANÇADO DE MAPEAMENTO DE CORRETORAS
# ============================================================================

# Configuração das corretoras com pesos, categorias e IDs conhecidos
CORRETORAS_CONFIG = {
    # INSTITUCIONAL (Alto peso - movimentam mercado)
    # Baseado no arquivo corretoras.txt fornecido pelo usuário
    'UBS': {
        'peso': 1.7, 
        'categoria': 'institucional', 
        'ids': [8], 
        'nome_completo': 'UBS Brasil',
        'descricao': 'Banco suíço com operação institucional no Brasil'
    },
    'Merrill': {
        'peso': 1.6, 
        'categoria': 'institucional',
        'ids': [13],
        'nome_completo': 'Merrill Lynch',
        'descricao': 'Banco de investimento americano (Bank of America)'
    },
    'JPMorgan': {
        'peso': 1.6, 
        'categoria': 'institucional',
        'ids': [16],
        'nome_completo': 'JPMorgan Chase',
        'descricao': 'Maior banco americano'
    },
    'Agora': {
        'peso': 1.5, 
        'categoria': 'institucional',
        'ids': [39],
        'nome_completo': 'Agora Investimentos',
        'descricao': 'Corretora institucional brasileira'
    },
    'Morgan': {
        'peso': 1.5, 
        'categoria': 'institucional',
        'ids': [40],
        'nome_completo': 'Morgan Stanley',
        'descricao': 'Banco de investimento americano'
    },
    'Tullett': {
        'peso': 1.4, 
        'categoria': 'institucional',
        'ids': [127],
        'nome_completo': 'Tullett Prebon',
        'descricao': 'Corretora internacional especializada em renda fixa'
    },
    'Ativa': {
        'peso': 1.4,
        'categoria': 'institucional', 
        'ids': [147],
        'nome_completo': 'Ativa Investimentos',
        'descricao': 'Corretora brasileira com operação institucional'
    },
    'Goldman': {
        'peso': 1.3, 
        'categoria': 'institucional',
        'ids': [238],
        'nome_completo': 'Goldman Sachs',
        'descricao': 'Banco de investimento americano'
    },
    'Ideal': {
        'peso': 1.3, 
        'categoria': 'institucional',
        'ids': [1618],
        'nome_completo': 'Ideal Investimentos',
        'descricao': 'Corretora institucional brasileira'
    },
    
    # VAREJO (Peso baixo/médio - indicadores de sentimento)
    # Baseado no arquivo corretoras.txt fornecido pelo usuário
    'XP': {
        'peso': 1.4, 
        'categoria': 'varejo', 
        'ids': [3, 188, 308, 386],  # Mantendo IDs do newagents.dat
        'nome_completo': 'XP Investimentos (inclui Rico e Clear)',
        'descricao': 'Maior corretora de varejo do Brasil - líder absoluta em volume'
    },
    'BTG': {
        'peso': 1.0, 
        'categoria': 'varejo',
        'ids': [85],  # Correção: era 85, não 88
        'nome_completo': 'BTG Pactual',
        'descricao': 'Banco com forte atuação no varejo'
    },
    
    # OUTROS (Peso médio) - Corretoras descobertas na execução
    'Genial': {
        'peso': 1.2,
        'categoria': 'outros',
        'ids': [120],  # ID descoberto - alto volume R$ 248M
        'nome_completo': 'Genial Investimentos',
        'descricao': 'Corretora digital brasileira'
    },
    'Toro': {
        'peso': 0.9,
        'categoria': 'varejo',
        'ids': [4090],  # ID descoberto - R$ 118M volume
        'nome_completo': 'Toro Investimentos',
        'descricao': 'Corretora digital de varejo'
    },
    'Elliot_Warren': {
        'peso': 1.1,
        'categoria': 'outros', 
        'ids': [92],  # ID descoberto - R$ 31M volume
        'nome_completo': 'Elliot-Warren',
        'descricao': 'Corretora de investimentos'
    },
    'CM_Capital': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [88],  # ID descoberto - R$ 30M volume
        'nome_completo': 'CM Capital Markets',
        'descricao': 'Corretora de capitais'
    },
    'Terra': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [107],  # ID descoberto - R$ 14M volume
        'nome_completo': 'Terra Investimentos',
        'descricao': 'Corretora brasileira'
    },
    'Itau': {
        'peso': 1.2,
        'categoria': 'outros',
        'ids': [114],  # ID fornecido pelo usuário
        'nome_completo': 'Itaú Corretora',
        'descricao': 'Corretora do maior banco privado do Brasil'
    },
    'Bradesco': {
        'peso': 1.1,
        'categoria': 'outros', 
        'ids': [72],  # ID fornecido pelo usuário
        'nome_completo': 'Bradesco Corretora',
        'descricao': 'Corretora do segundo maior banco privado do Brasil'
    },
    'BGC_Liquidez': {
        'peso': 1.2,
        'categoria': 'outros',
        'ids': [122],  # ID fornecido pelo usuário
        'nome_completo': 'BGC Liquidez',
        'descricao': 'Corretora especializada em liquidez'
    },
    'Santander': {
        'peso': 1.1,
        'categoria': 'outros',
        'ids': [27],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Santander Corretora',
        'descricao': 'Corretora do Banco Santander'
    },
    'Safra': {
        'peso': 1.2,
        'categoria': 'outros',
        'ids': [59],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Safra Corretora',
        'descricao': 'Corretora do Banco Safra'
    },
    'Master': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [83],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Master Corretora',
        'descricao': 'Corretora brasileira'
    },
    'Nova_Futura': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [93],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Nova Futura Investimentos',
        'descricao': 'Corretora brasileira'
    },
    'Mirae': {
        'peso': 1.3,
        'categoria': 'outros',
        'ids': [262],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Mirae Asset',
        'descricao': 'Corretora sul-coreana'
    },
    'LEV': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [746],  # ID do arquivo mapear ID.txt
        'nome_completo': 'LEV Corretora',
        'descricao': 'Corretora brasileira'
    },
    'Inter': {
        'peso': 0.9,
        'categoria': 'outros',
        'ids': [1099],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Inter Investimentos',
        'descricao': 'Corretora do Banco Inter'
    },
    'C6': {
        'peso': 0.9,
        'categoria': 'outros',
        'ids': [6003],  # ID do arquivo mapear ID.txt
        'nome_completo': 'C6 Bank Investimentos',
        'descricao': 'Corretora do C6 Bank'
    },
    'Citigroup': {
        'peso': 1.2,
        'categoria': 'outros',
        'ids': [77],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Citigroup Corretora',
        'descricao': 'Corretora do Citigroup'
    },
    'Daycoval': {
        'peso': 1.0,
        'categoria': 'outros',
        'ids': [346],  # ID do arquivo mapear ID.txt
        'nome_completo': 'Daycoval Corretora',
        'descricao': 'Corretora do Banco Daycoval'
    },
    'StoneX': {
        'peso': 1.5,
        'categoria': 'institucional',
        'ids': [1130],  # Novo ID fornecido pelo usuário
        'nome_completo': 'StoneX Financial Inc.',
        'descricao': 'Corretora internacional americana especializada em commodities e derivativos'
    }
}

# Mapeamento reverso: ID -> informações da corretora
ID_TO_CORRETORA = {}
for nome, config in CORRETORAS_CONFIG.items():
    for corretora_id in config['ids']:
        ID_TO_CORRETORA[corretora_id] = {
            'nome': nome,
            'nome_completo': config['nome_completo'],
            'peso': config['peso'],
            'categoria': config['categoria'],
            'descricao': config['descricao']
        }

# Estruturas baseadas na documentação da ProfitDLL
class TAssetIDRec(Structure):
    _fields_ = [
        ("pwcTicker", c_wchar_p),
        ("pwcBolsa", c_wchar_p), 
        ("nFeed", c_int)
    ]

class TConnectorAccountIdentifier(Structure):
    _fields_ = [
        ("Version", c_byte),
        ("BrokerID", c_int),
        ("AccountID", c_wchar_p),
        ("SubAccountID", c_wchar_p),
        ("Reserved", c_int64)
    ]

class TConnectorAssetIdentifier(Structure):
    _fields_ = [
        ("Version", c_byte),
        ("Ticker", c_wchar_p),
        ("Exchange", c_wchar_p),
        ("FeedType", c_byte)
    ]

# Tipos de callback
TStateCallback = WINFUNCTYPE(None, c_int, c_int)
TNewTradeCallback = WINFUNCTYPE(None, TAssetIDRec, c_wchar_p, c_uint, c_double, 
                                c_double, c_int, c_int, c_int, c_int, c_char)
TProgressCallback = WINFUNCTYPE(None, TAssetIDRec, c_int)
TAccountCallback = WINFUNCTYPE(None, c_int, c_wchar_p, c_wchar_p, c_wchar_p)
TTinyBookCallback = WINFUNCTYPE(None, TAssetIDRec, c_double, c_int, c_int)

# Callbacks para debug e inicialização
def empty_callback(*args):
    pass

def debug_state_callback(nType, nResult):
    """Callback de debug para estados da conexão"""
    states = {
        0: {0: "✅ Login: Conectado", 1: "❌ Login: Inválido", 2: "❌ Senha inválida", 3: "❌ Senha bloqueada"},
        1: {0: "Broker: Desconectado", 1: "Broker: Conectando", 2: "✅ Broker: Conectado"},
        2: {0: "Market: Desconectado", 1: "Market: Conectando", 2: "Market: Waiting", 4: "✅ Market: Conectado"},
        3: {0: "✅ Ativação: Válida", 1: "❌ Ativação: Inválida"}
    }
    msg = states.get(nType, {}).get(nResult, f"State: Tipo={nType}, Result={nResult}")
    print(f"[DEBUG] {msg}")

def debug_progress_callback(asset_id, progress):
    """Callback de debug para progresso de subscrição"""
    ticker = asset_id.pwcTicker if asset_id.pwcTicker else "UNKNOWN"
    print(f"📊 Progress: {ticker} - {progress}%")

# Convertendo para os tipos corretos
state_callback = TStateCallback(debug_state_callback)
progress_callback = TProgressCallback(debug_progress_callback)
account_callback = TAccountCallback(empty_callback)
tiny_book_callback = TTinyBookCallback(empty_callback)

# ============================================================================
# FUNÇÕES UTILITÁRIAS PARA MAPEAMENTO DE CORRETORAS
# ============================================================================

def get_corretora_info(corretora_id):
    """
    Obtém informações de uma corretora pelo ID
    
    Args:
        corretora_id: ID da corretora
        
    Returns:
        Dict com informações da corretora ou None se não encontrada
    """
    return ID_TO_CORRETORA.get(corretora_id, None)

def get_corretora_categoria(corretora_id):
    """Obtém a categoria de uma corretora pelo ID"""
    info = get_corretora_info(corretora_id)
    return info['categoria'] if info else 'desconhecida'

def get_corretora_peso(corretora_id):
    """Obtém o peso de uma corretora pelo ID"""
    info = get_corretora_info(corretora_id)
    return info['peso'] if info else 1.0

def get_corretora_nome_display(corretora_id):
    """
    Obtém nome para display de uma corretora pelo ID
    
    Returns:
        String formatada para exibição: "Nome (ID)" ou apenas "ID" se não mapeada
    """
    info = get_corretora_info(corretora_id)
    if info:
        return f"{info['nome']} (ID {corretora_id})"
    else:
        return f"ID {corretora_id}"

def is_corretora_institucional(corretora_id):
    """Verifica se uma corretora é institucional"""
    return get_corretora_categoria(corretora_id) == 'institucional'

def is_corretora_varejo(corretora_id):
    """Verifica se uma corretora é de varejo"""
    return get_corretora_categoria(corretora_id) == 'varejo'

def get_emoji_by_categoria(categoria):
    """Retorna emoji baseado na categoria da corretora"""
    emojis = {
        'institucional': '🏦',
        'varejo': '🏪', 
        'outros': '🏢',
        'desconhecida': '❓'
    }
    return emojis.get(categoria, '❓')

def calcular_score_fluxo(trades_data):
    """
    Calcula score de fluxo institucional vs varejo
    
    Args:
        trades_data: Dict com dados dos trades por corretora
        
    Returns:
        Dict com scores e análise
    """
    score_institucional = 0
    score_varejo = 0
    score_outros = 0
    
    volume_institucional = 0
    volume_varejo = 0
    volume_outros = 0
    
    for corretora_id, data in trades_data.items():
        categoria = get_corretora_categoria(corretora_id)
        peso = get_corretora_peso(corretora_id)
        volume_total = data.get('volume_total_agressor', 0)
        
        score_ponderado = volume_total * peso
        
        if categoria == 'institucional':
            score_institucional += score_ponderado
            volume_institucional += volume_total
        elif categoria == 'varejo':
            score_varejo += score_ponderado  
            volume_varejo += volume_total
        else:
            score_outros += score_ponderado
            volume_outros += volume_total
    
    score_total = score_institucional + score_varejo + score_outros
    
    return {
        'score_institucional': score_institucional,
        'score_varejo': score_varejo,
        'score_outros': score_outros,
        'score_total': score_total,
        'volume_institucional': volume_institucional,
        'volume_varejo': volume_varejo, 
        'volume_outros': volume_outros,
        'percentual_institucional': (score_institucional / score_total * 100) if score_total > 0 else 0,
        'percentual_varejo': (score_varejo / score_total * 100) if score_total > 0 else 0,
        'percentual_outros': (score_outros / score_total * 100) if score_total > 0 else 0,
        'dominio': 'institucional' if score_institucional > (score_varejo + score_outros) else 
                  'varejo' if score_varejo > (score_institucional + score_outros) else 'equilibrado'
    }

def calcular_smart_money_consensus(trades_data, timeframe_minutes=15):
    """
    Calcula o consenso das corretoras institucionais (Smart Money)
    
    Args:
        trades_data: Dados de trades por corretora
        timeframe_minutes: Janela de tempo para análise
        
    Returns:
        Dict com análise do smart money consensus
    """
    if not trades_data:
        return {
            'consensus_direction': 'NEUTRO',
            'consensus_strength': 0,
            'institutional_bias': 'NEUTRO',
            'smart_money_signal': 'AGUARDAR',
            'leading_institutions': [],
            'confidence': 0
        }
    
    # Separar corretoras institucionais
    institutional_stats = {}
    total_institutional_volume = 0
    total_institutional_buy = 0
    total_institutional_sell = 0
    
    for corretora_id, data in trades_data.items():
        if get_corretora_categoria(corretora_id) == 'institucional':
            # Usar volume total se disponível, senão usar apenas agressão
            if 'volume_total_agressor' in data and data.get('volume_total_agressor', 0) > 0:
                volume_total = data.get('volume_total_agressor', 0)
                volume_buy = data.get('volume_compra_agressor', 0)
                volume_sell = data.get('volume_venda_agressor', 0)
            else:
                # Fallback: apenas volumes de agressão
                volume_buy = data.get('volume_compra_agressor', 0)
                volume_sell = data.get('volume_venda_agressor', 0)
                volume_total = volume_buy + volume_sell
            peso = get_corretora_peso(corretora_id)
            
            if volume_total > 0:
                institutional_stats[corretora_id] = {
                    'volume_buy': volume_buy,
                    'volume_sell': volume_sell,
                    'volume_total': volume_total,
                    'peso': peso,
                    'bias': 'COMPRA' if volume_buy > volume_sell else 'VENDA',
                    'bias_strength': abs(volume_buy - volume_sell) / volume_total * 100,
                    'weighted_score': volume_total * peso
                }
                
                total_institutional_volume += volume_total
                total_institutional_buy += volume_buy
                total_institutional_sell += volume_sell
    
    if not institutional_stats or total_institutional_volume == 0:
        return {
            'consensus_direction': 'NEUTRO',
            'consensus_strength': 0,
            'institutional_bias': 'NEUTRO',
            'smart_money_signal': 'AGUARDAR',
            'leading_institutions': [],
            'confidence': 0
        }
    
    # Calcular consenso direccional
    buy_percentage = (total_institutional_buy / total_institutional_volume) * 100
    sell_percentage = (total_institutional_sell / total_institutional_volume) * 100
    
    # Definir direção do consenso
    if buy_percentage > 65:
        consensus_direction = 'COMPRA'
        consensus_strength = buy_percentage
    elif sell_percentage > 65:
        consensus_direction = 'VENDA'
        consensus_strength = sell_percentage
    else:
        consensus_direction = 'NEUTRO'
        consensus_strength = 50
    
    # Identificar instituições líderes (top 3 por volume ponderado)
    leading_institutions = sorted(
        institutional_stats.items(), 
        key=lambda x: x[1]['weighted_score'], 
        reverse=True
    )[:3]
    
    leading_names = []
    for corretora_id, stats in leading_institutions:
        info = get_corretora_info(corretora_id)
        leading_names.append({
            'nome': info['nome'] if info else f'ID_{corretora_id}',
            'volume_total': stats['volume_total'],
            'bias': stats['bias'],
            'peso': stats['peso']
        })
    
    # Gerar sinal de smart money
    if consensus_strength > 70:
        smart_money_signal = consensus_direction
        confidence = min(95, consensus_strength)
    elif consensus_strength > 60:
        smart_money_signal = f'{consensus_direction}_FRACO'
        confidence = consensus_strength
    else:
        smart_money_signal = 'AGUARDAR'
        confidence = 0
    
    # Calcular bias institucional geral
    institutional_bias = 'COMPRA' if buy_percentage > sell_percentage else 'VENDA'
    
    return {
        'consensus_direction': consensus_direction,
        'consensus_strength': round(consensus_strength, 1),
        'institutional_bias': institutional_bias,
        'smart_money_signal': smart_money_signal,
        'leading_institutions': leading_names,
        'confidence': round(confidence, 1),
        'buy_percentage': round(buy_percentage, 1),
        'sell_percentage': round(sell_percentage, 1),
        'total_institutions_active': len(institutional_stats),
        'total_institutional_volume': total_institutional_volume
    }

def get_smart_money_score(consensus_analysis):
    """
    Calcula score de 0-100 baseado no consenso do smart money
    
    Args:
        consensus_analysis: Resultado de calcular_smart_money_consensus()
        
    Returns:
        int: Score de 0-100 (0=evitar, 50=neutro, 100=forte seguir)
    """
    signal = consensus_analysis['smart_money_signal']
    confidence = consensus_analysis['confidence']
    strength = consensus_analysis['consensus_strength']
    
    if signal in ['COMPRA', 'VENDA']:
        # Sinal forte - score alto
        return min(100, int(confidence + (strength - 70) * 2))
    elif signal in ['COMPRA_FRACO', 'VENDA_FRACO']:
        # Sinal fraco - score moderado
        return min(75, int(confidence))
    else:
        # Sem sinal - score neutro/baixo
        return max(10, int(confidence / 2))

# ============================================================================
# SISTEMA DE COLETA DE DADOS PARA ML
# ============================================================================

class DataCollector:
    """Sistema inteligente de coleta e armazenamento de dados para ML"""
    
    def __init__(self, base_path="./data"):
        """
        Inicializa o coletor de dados
        
        Args:
            base_path: Diretório base para armazenar os dados
        """
        self.base_path = Path(base_path)
        self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
        self.setup_directories()
        
        # Arquivos de dados
        self.trades_file = self.base_path / "trades" / f"trades_{self.session_id}.csv"
        self.regimes_file = self.base_path / "regimes" / f"regimes_{self.session_id}.json" 
        self.temperature_file = self.base_path / "temperature" / f"temperature_{self.session_id}.json"
        self.snapshots_file = self.base_path / "snapshots" / f"snapshots_{self.session_id}.json"
        
        # Contadores
        self.total_trades_collected = 0
        self.total_regimes_recorded = 0
        self.total_snapshots = 0
        
        self.initialize_files()
    
    def setup_directories(self):
        """Cria estrutura de diretórios"""
        directories = ["trades", "regimes", "temperature", "snapshots", "features", "sessions"]
        for directory in directories:
            (self.base_path / directory).mkdir(parents=True, exist_ok=True)
    
    def initialize_files(self):
        """Inicializa arquivos com headers"""
        # CSV de trades
        trade_headers = [
            'timestamp', 'session_id', 'ticker', 'price', 'volume', 'quantity',
            'buy_agent', 'sell_agent', 'trade_type', 'buy_categoria', 'sell_categoria',
            'buy_peso', 'sell_peso', 'buy_nome', 'sell_nome'
        ]
        
        with open(self.trades_file, 'w', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            writer.writerow(trade_headers)
        
        # Arquivos JSON iniciais
        for json_file in [self.regimes_file, self.temperature_file, self.snapshots_file]:
            with open(json_file, 'w', encoding='utf-8') as f:
                json.dump([], f)
        
        print(f"[FILE] Sistema de coleta inicializado - Sessao: {self.session_id}")
        print(f"   Diretório: {self.base_path.absolute()}")
    
    def collect_trade(self, asset_id, price, volume, quantity, buy_agent, sell_agent, trade_type):
        """
        Coleta dados de um trade individual
        
        Args:
            asset_id: ID do ativo
            price: Preço do trade
            volume: Volume financeiro
            quantity: Quantidade
            buy_agent: ID da corretora compradora
            sell_agent: ID da corretora vendedora
            trade_type: Tipo do trade
        """
        try:
            ticker = asset_id.pwcTicker if asset_id.pwcTicker else "UNKNOWN"
            timestamp = datetime.now().isoformat()
            
            # Obter informações das corretoras
            buy_info = get_corretora_info(buy_agent)
            sell_info = get_corretora_info(sell_agent)
            
            trade_data = [
                timestamp, self.session_id, ticker, price, volume, quantity,
                buy_agent, sell_agent, trade_type,
                buy_info['categoria'] if buy_info else 'desconhecida',
                sell_info['categoria'] if sell_info else 'desconhecida',
                buy_info['peso'] if buy_info else 1.0,
                sell_info['peso'] if sell_info else 1.0,
                buy_info['nome'] if buy_info else f'ID_{buy_agent}',
                sell_info['nome'] if sell_info else f'ID_{sell_agent}'
            ]
            
            # Escrever no CSV
            with open(self.trades_file, 'a', newline='', encoding='utf-8') as f:
                writer = csv.writer(f)
                writer.writerow(trade_data)
            
            self.total_trades_collected += 1
            
        except Exception as e:
            print(f"Erro ao coletar trade: {e}")
    
    def collect_regime_analysis(self, regime_data):
        """
        Coleta análise de regime de mercado
        
        Args:
            regime_data: Dict com dados do regime
        """
        try:
            # Adicionar metadados da sessão
            regime_record = {
                'timestamp': datetime.now().isoformat(),
                'session_id': self.session_id,
                **regime_data
            }
            
            # Ler dados existentes e adicionar novo
            with open(self.regimes_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            data.append(regime_record)
            
            with open(self.regimes_file, 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=2, ensure_ascii=False, default=str)
            
            self.total_regimes_recorded += 1
            
        except Exception as e:
            print(f"Erro ao coletar regime: {e}")
    
    def collect_temperature_analysis(self, temperature_data):
        """
        Coleta análise de temperatura do mercado
        
        Args:
            temperature_data: Dict com dados de temperatura
        """
        try:
            # Adicionar metadados da sessão
            temp_record = {
                'session_id': self.session_id,
                **temperature_data
            }
            
            # Ler dados existentes e adicionar novo
            with open(self.temperature_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            data.append(temp_record)
            
            with open(self.temperature_file, 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=2, ensure_ascii=False, default=str)
                
        except Exception as e:
            print(f"Erro ao coletar temperatura: {e}")
    
    def collect_market_snapshot(self, all_stats, fluxo_analysis, temp_analysis, regime_analysis):
        """
        Coleta snapshot completo do estado do mercado
        
        Args:
            all_stats: Estatísticas de todas as corretoras
            fluxo_analysis: Análise de fluxo
            temp_analysis: Análise de temperatura
            regime_analysis: Análise de regime
        """
        try:
            snapshot = {
                'timestamp': datetime.now().isoformat(),
                'session_id': self.session_id,
                'market_stats': {
                    'total_corretoras_ativas': len(all_stats),
                    'volume_total': sum(s.get('volume_compra_agressor', 0) + s.get('volume_venda_agressor', 0) 
                                       for s in all_stats.values()),
                    'contratos_total': sum(s.get('qtd_compra_agressor', 0) + s.get('qtd_venda_agressor', 0) 
                                          for s in all_stats.values()),
                    'trades_total': sum(s.get('total_trades', 0) for s in all_stats.values())
                },
                'fluxo': fluxo_analysis,
                'temperatura': temp_analysis,
                'regime': regime_analysis,
                'top_corretoras': self._get_top_corretoras_snapshot(all_stats)
            }
            
            # Ler dados existentes e adicionar novo
            with open(self.snapshots_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            data.append(snapshot)
            
            with open(self.snapshots_file, 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=2, ensure_ascii=False, default=str)
            
            self.total_snapshots += 1
            
        except Exception as e:
            print(f"Erro ao coletar snapshot: {e}")
    
    def _get_top_corretoras_snapshot(self, all_stats):
        """Gera snapshot das top corretoras por categoria"""
        top_data = {}
        
        for categoria in ['institucional', 'varejo', 'outros']:
            top_categoria = []
            for corr_id, stats in all_stats.items():
                if get_corretora_categoria(corr_id) == categoria:
                    volume_total = stats.get('volume_compra_agressor', 0) + stats.get('volume_venda_agressor', 0)
                    if volume_total > 0:
                        info = get_corretora_info(corr_id)
                        top_categoria.append({
                            'id': corr_id,
                            'nome': info['nome'] if info else f'ID_{corr_id}',
                            'volume_total': volume_total,
                            'peso': info['peso'] if info else 1.0,
                            'trades': stats.get('total_trades', 0)
                        })
            
            # Ordenar por volume e pegar top 3
            top_categoria.sort(key=lambda x: x['volume_total'], reverse=True)
            top_data[categoria] = top_categoria[:3]
        
        return top_data
    
    def generate_session_summary(self):
        """Gera resumo da sessão de coleta"""
        return {
            'session_id': self.session_id,
            'total_trades_collected': self.total_trades_collected,
            'total_regimes_recorded': self.total_regimes_recorded,
            'total_snapshots': self.total_snapshots,
            'files_created': {
                'trades': str(self.trades_file),
                'regimes': str(self.regimes_file),
                'temperature': str(self.temperature_file),
                'snapshots': str(self.snapshots_file)
            }
        }
    
    def export_ml_features(self):
        """
        Exporta features estruturadas para ML
        
        Returns:
            Dict com features processadas
        """
        try:
            # Ler dados de temperatura
            with open(self.temperature_file, 'r', encoding='utf-8') as f:
                temp_data = json.load(f)
            
            # Ler dados de regimes  
            with open(self.regimes_file, 'r', encoding='utf-8') as f:
                regime_data = json.load(f)
            
            # Processar features
            features = {
                'temperature_series': [t['temperatura_geral']['temperatura'] for t in temp_data],
                'regime_sequence': [r['regime'] for r in regime_data],
                'confidence_series': [r['confianca'] for r in regime_data],
                'institutional_flow': [r['stats'].get('percentual_institucional', 0) for r in regime_data if 'stats' in r],
                'session_metadata': {
                    'session_id': self.session_id,
                    'total_samples': len(temp_data),
                    'session_duration_minutes': len(temp_data) * 0.25  # Assumindo coleta a cada 15s
                }
            }
            
            # Salvar features
            features_file = self.base_path / "features" / f"features_{self.session_id}.json"
            with open(features_file, 'w', encoding='utf-8') as f:
                json.dump(features, f, indent=2, ensure_ascii=False)
            
            return features
            
        except Exception as e:
            print(f"Erro ao exportar features: {e}")
            return {}

# ============================================================================
# FASE 1: SISTEMA DE TEMPERATURA DO MERCADO
# ============================================================================

def calcular_temperatura_mercado(volume_total_contratos):
    """
    Calcula a temperatura do mercado baseada no conceito: 2000 contratos = 1 grau
    
    Args:
        volume_total_contratos: Volume total de contratos negociados
        
    Returns:
        Dict com temperatura e classificação
    """
    temperatura = volume_total_contratos / 2000.0
    
    # Classificação da temperatura
    if temperatura < 5:
        classificacao = 'fria'
        emoji = '🧊'
        descricao = 'Mercado com baixa atividade'
    elif temperatura < 15:
        classificacao = 'morna'
        emoji = '🌡️'
        descricao = 'Mercado com atividade moderada'
    elif temperatura < 25:
        classificacao = 'quente'
        emoji = '🔥'
        descricao = 'Mercado com alta atividade'
    else:
        classificacao = 'fervendo'
        emoji = '🌋'
        descricao = 'Mercado com atividade extrema'
    
    return {
        'temperatura': round(temperatura, 1),
        'classificacao': classificacao,
        'emoji': emoji,
        'descricao': descricao,
        'volume_contratos': volume_total_contratos
    }

def get_mudanca_temperatura(temp_atual, temp_anterior):
    """
    Calcula a mudança de temperatura entre duas leituras
    
    Args:
        temp_atual: Temperatura atual
        temp_anterior: Temperatura anterior
        
    Returns:
        Dict com mudança e análise
    """
    if temp_anterior is None or temp_anterior == 0:
        return {
            'mudanca': 0,
            'percentual': 0,
            'tendencia': 'inicial',
            'emoji': '📊'
        }
    
    mudanca = temp_atual - temp_anterior
    percentual = (mudanca / temp_anterior) * 100 if temp_anterior > 0 else 0
    
    if abs(mudanca) < 1:
        tendencia = 'estavel'
        emoji = '➡️'
    elif mudanca > 3:
        tendencia = 'aquecendo_rapido'
        emoji = '📈🔥'
    elif mudanca > 0:
        tendencia = 'aquecendo'
        emoji = '📈'
    elif mudanca < -3:
        tendencia = 'esfriando_rapido'
        emoji = '📉❄️'
    else:
        tendencia = 'esfriando'
        emoji = '📉'
    
    return {
        'mudanca': round(mudanca, 1),
        'percentual': round(percentual, 1),
        'tendencia': tendencia,
        'emoji': emoji
    }

def analisar_temperatura_por_categoria(trades_data):
    """
    Analisa temperatura por categoria de corretora
    
    Args:
        trades_data: Dict com dados dos trades por corretora
        
    Returns:
        Dict com temperatura por categoria
    """
    temp_por_categoria = {
        'institucional': {'volume': 0, 'temperatura': 0},
        'varejo': {'volume': 0, 'temperatura': 0},
        'outros': {'volume': 0, 'temperatura': 0},
        'desconhecida': {'volume': 0, 'temperatura': 0}  # Adicionar categoria para não mapeadas
    }
    
    for corretora_id, data in trades_data.items():
        categoria = get_corretora_categoria(corretora_id)
        qtd_total = data.get('qtd_compra_agressor', 0) + data.get('qtd_venda_agressor', 0)
        
        # Garantir que a categoria existe no dict
        if categoria not in temp_por_categoria:
            categoria = 'desconhecida'
        
        temp_por_categoria[categoria]['volume'] += qtd_total
    
    # Calcular temperatura por categoria
    for categoria in temp_por_categoria:
        volume = temp_por_categoria[categoria]['volume']
        temp_por_categoria[categoria]['temperatura'] = round(volume / 2000.0, 1)
        temp_por_categoria[categoria]['info'] = calcular_temperatura_mercado(volume)
    
    return temp_por_categoria

# ============================================================================
# FASE 2: CLASSIFICAÇÃO DE REGIMES DE MERCADO
# ============================================================================

def get_regime_info(regime_type):
    """
    Obtém informações sobre um tipo de regime
    
    Args:
        regime_type: Tipo do regime
        
    Returns:
        Dict com informações do regime
    """
    regimes_info = {
        'trending_bull': {
            'nome': 'Tendência de Alta',
            'emoji': '🐂',
            'descricao': 'Mercado em forte tendência altista',
            'cor': 'verde',
            'confianca_minima': 70
        },
        'trending_bear': {
            'nome': 'Tendência de Baixa',
            'emoji': '🐻', 
            'descricao': 'Mercado em forte tendência baixista',
            'cor': 'vermelho',
            'confianca_minima': 70
        },
        'sideways': {
            'nome': 'Lateral',
            'emoji': '↔️',
            'descricao': 'Mercado sem direção definida',
            'cor': 'amarelo',
            'confianca_minima': 60
        },
        'alta_volatilidade': {
            'nome': 'Alta Volatilidade',
            'emoji': '⚡',
            'descricao': 'Mercado com movimentos erráticos',
            'cor': 'roxo',
            'confianca_minima': 80
        }
    }
    
    return regimes_info.get(regime_type, {
        'nome': 'Indefinido',
        'emoji': '❓',
        'descricao': 'Regime não identificado',
        'cor': 'cinza',
        'confianca_minima': 50
    })

def calcular_percentual_corretoras_positivas(trades_data):
    """
    Calcula percentual de corretoras com saldo positivo
    
    Args:
        trades_data: Dict com dados dos trades por corretora
        
    Returns:
        Dict com estatísticas de performance das corretoras
    """
    if not trades_data:
        return {'percentual_positivas': 50, 'total_corretoras': 0, 'positivas': 0}
    
    corretoras_positivas = 0
    total_corretoras = len(trades_data)
    
    for corretora_id, data in trades_data.items():
        # Calcular "P&L" estimado baseado no volume de compra vs venda
        volume_compra = data.get('volume_compra_agressor', 0)
        volume_venda = data.get('volume_venda_agressor', 0)
        
        # Assumir que quem tem mais volume de compra está "ganhando" no momento
        if volume_compra > volume_venda:
            corretoras_positivas += 1
    
    percentual = (corretoras_positivas / total_corretoras * 100) if total_corretoras > 0 else 50
    
    return {
        'percentual_positivas': round(percentual, 1),
        'total_corretoras': total_corretoras,
        'positivas': corretoras_positivas,
        'negativas': total_corretoras - corretoras_positivas
    }

def detectar_alta_volatilidade(historico_temperatura, trades_data):
    """
    Detecta se há alta volatilidade baseada em mudanças rápidas
    
    Args:
        historico_temperatura: Lista com histórico de temperatura
        trades_data: Dados atuais dos trades
        
    Returns:
        Dict com análise de volatilidade
    """
    if len(historico_temperatura) < 3:
        return {
            'alta_volatilidade': False,
            'score_volatilidade': 0,
            'motivo': 'Histórico insuficiente'
        }
    
    # Analisar últimas 3 leituras de temperatura
    ultimas_temps = [h['temperatura_geral']['temperatura'] for h in historico_temperatura[-3:]]
    
    # Calcular mudanças rápidas
    mudancas = []
    for i in range(1, len(ultimas_temps)):
        mudanca = abs(ultimas_temps[i] - ultimas_temps[i-1])
        mudancas.append(mudanca)
    
    mudanca_media = sum(mudancas) / len(mudancas) if mudancas else 0
    
    # Critérios para alta volatilidade
    volatilidade_temperatura = mudanca_media > 3.0  # Mudanças > 3° rapidamente
    
    # Análise de dispersão de volumes por corretora
    volumes = []
    for data in trades_data.values():
        volume_total = data.get('volume_compra_agressor', 0) + data.get('volume_venda_agressor', 0)
        if volume_total > 0:
            volumes.append(volume_total)
    
    volatilidade_volume = False
    if len(volumes) > 3:
        import statistics
        cv = statistics.stdev(volumes) / statistics.mean(volumes) if statistics.mean(volumes) > 0 else 0
        volatilidade_volume = cv > 1.5  # Coeficiente de variação alto
    
    # Score final de volatilidade
    score = 0
    motivos = []
    
    if volatilidade_temperatura:
        score += 40
        motivos.append(f'Temp oscilou {mudanca_media:.1f}° rapidamente')
    
    if volatilidade_volume:
        score += 40
        motivos.append('Grande dispersão nos volumes')
    
    # Adicionar pontos se há muitas corretoras pequenas ativas
    if len(trades_data) > 20:
        score += 20
        motivos.append('Muitas corretoras ativas simultaneamente')
    
    return {
        'alta_volatilidade': score >= 60,
        'score_volatilidade': min(score, 100),
        'motivo': ' | '.join(motivos) if motivos else 'Mercado estável'
    }

def classificar_regime_mercado(trades_data, analise_temperatura, historico_temperatura):
    """
    Classifica o regime atual do mercado
    
    Args:
        trades_data: Dados dos trades
        analise_temperatura: Análise atual de temperatura  
        historico_temperatura: Histórico de temperatura
        
    Returns:
        Dict com classificação do regime
    """
    # 1. Obter dados básicos
    stats_corretoras = calcular_percentual_corretoras_positivas(trades_data)
    percentual_positivas = stats_corretoras['percentual_positivas']
    temperatura = analise_temperatura['temperatura_geral']['temperatura']
    
    # 2. Analisar fluxo institucional vs varejo
    fluxo = calcular_score_fluxo(trades_data)
    dominio_institucional = fluxo['dominio'] == 'institucional'
    percentual_institucional = fluxo['percentual_institucional']
    
    # 3. Detectar alta volatilidade
    vol_analise = detectar_alta_volatilidade(historico_temperatura, trades_data)
    
    # 4. Classificar regime baseado nos critérios
    regime = 'sideways'  # padrão
    confianca = 50
    gatilhos = []
    
    # ALTA VOLATILIDADE tem prioridade
    if vol_analise['alta_volatilidade']:
        regime = 'alta_volatilidade'
        confianca = min(vol_analise['score_volatilidade'], 95)
        gatilhos.append(vol_analise['motivo'])
    
    # TRENDING BULL
    elif (percentual_positivas > 75 and 
          temperatura > 15 and 
          dominio_institucional and 
          percentual_institucional > 45):
        regime = 'trending_bull'
        confianca = min(70 + (percentual_positivas - 75) + (temperatura - 15) * 2, 95)
        gatilhos.extend([
            f'{percentual_positivas}% corretoras positivas',
            f'Temperatura {temperatura}°',
            f'Domínio institucional ({percentual_institucional:.1f}%)'
        ])
    
    # TRENDING BEAR  
    elif (percentual_positivas < 40 and 
          temperatura > 10 and
          percentual_institucional < 35):
        regime = 'trending_bear'
        confianca = min(70 + (40 - percentual_positivas) + (temperatura - 10) * 2, 95)
        gatilhos.extend([
            f'Apenas {percentual_positivas}% corretoras positivas',
            f'Temperatura {temperatura}°',
            f'Baixo fluxo institucional ({percentual_institucional:.1f}%)'
        ])
    
    # SIDEWAYS (padrão quando não é bull nem bear nem volátil)
    else:
        confianca = 60 if 40 <= percentual_positivas <= 75 else 45
        gatilhos.append(f'{percentual_positivas}% corretoras positivas (neutro)')
        if temperatura < 10:
            gatilhos.append(f'Baixa temperatura ({temperatura}°)')
    
    regime_info = get_regime_info(regime)
    
    return {
        'regime': regime,
        'confianca': min(max(confianca, 30), 95),  # Entre 30% e 95%
        'info': regime_info,
        'gatilhos': gatilhos,
        'stats': {
            'percentual_positivas': percentual_positivas,
            'temperatura': temperatura,
            'dominio': fluxo['dominio'],
            'percentual_institucional': percentual_institucional,
            'volatilidade_score': vol_analise['score_volatilidade']
        },
        'timestamp': datetime.now()
    }

# ============================================================================
# SISTEMA DE TRADING AUTOMÁTICO SIMULADO
# ============================================================================

class SimulatedOrder:
    """Representa uma ordem simulada"""
    
    def __init__(self, order_id, ticker, side, price, quantity, timestamp, strategy=""):
        self.order_id = order_id
        self.ticker = ticker
        self.side = side  # 'BUY' ou 'SELL'
        self.price = price
        self.quantity = quantity
        self.timestamp = timestamp
        self.status = 'ACTIVE'  # ACTIVE, FILLED, CANCELLED, STOPPED
        self.fill_price = None
        self.fill_timestamp = None
        self.strategy = strategy
        self.pnl = 0.0
        
    def fill_order(self, fill_price, fill_timestamp):
        """Marca a ordem como preenchida"""
        self.status = 'FILLED'
        self.fill_price = fill_price
        self.fill_timestamp = fill_timestamp
        
    def cancel_order(self):
        """Cancela a ordem"""
        self.status = 'CANCELLED'
        
    def trigger_stop(self, stop_price, stop_timestamp):
        """Aciona stop loss/take profit"""
        self.status = 'STOPPED'
        self.fill_price = stop_price
        self.fill_timestamp = stop_timestamp

class TradingEngine:
    """Engine de trading automático simulado"""
    
    def __init__(self, initial_capital=100000.0):
        self.initial_capital = initial_capital
        self.current_capital = initial_capital
        self.orders = {}  # order_id -> SimulatedOrder
        self.positions = {}  # ticker -> {'side': 'LONG/SHORT', 'quantity': int, 'avg_price': float, 'unrealized_pnl': float}
        self.trades_history = []
        self.decisions_history = []  # Histórico de todas as decisões tomadas
        self.order_counter = 1
        self.enabled = True
        self.risk_per_trade = 0.02  # 2% do capital por trade
        self.max_position_size = 0.1  # 10% do capital por posição
        
        # Configurações de trading
        self.config = self._load_optimized_config()
        
        # Estatísticas
        self.stats = {
            'total_trades': 0,
            'winning_trades': 0,
            'losing_trades': 0,
            'total_pnl': 0.0,
            'max_drawdown': 0.0,
            'max_capital': initial_capital,
            'contracts_today': 0,
            'last_trade_date': datetime.now().date()
        }
        
    def _load_optimized_config(self):
        """Carrega configuração otimizada baseada em dados históricos"""
        default_config = {
            'min_confidence': 70,  # Confiança mínima para entrada
            'min_temperature': 10,  # Temperatura mínima do mercado
            'stop_loss_pct': 0.015,  # 1.5% stop loss
            'take_profit_pct': 0.025,  # 2.5% take profit
            'max_contracts_per_day': 5,
            'institutional_weight_min': 0.4  # 40% mínimo de fluxo institucional para bull
        }
        
        # Tentar carregar configuração otimizada
        config_file = 'config_ml_amanha.json'
        if os.path.exists(config_file):
            try:
                import json
                with open(config_file, 'r', encoding='utf-8') as f:
                    optimized = json.load(f)
                
                # Aplicar parâmetros otimizados
                params = optimized.get('parametros_otimizados', {})
                
                if 'temperatura_minima_entrada' in params:
                    # Normalizar temperatura (os dados parecem estar em escala diferente)
                    temp_otim = params['temperatura_minima_entrada']
                    if temp_otim > 100:  # Se está em escala alta, normalizar
                        default_config['min_temperature'] = max(10, temp_otim / 100)
                    else:
                        default_config['min_temperature'] = temp_otim
                        
                if 'confianca_regime_minima' in params:
                    default_config['min_confidence'] = params['confianca_regime_minima']
                    
                if 'fluxo_institucional_dominante' in params:
                    default_config['institutional_weight_min'] = params['fluxo_institucional_dominante'] / 100
                
                print(f"CONFIGURACAO OTIMIZADA CARREGADA:")
                print(f"   Temperatura minima: {default_config['min_temperature']:.1f} graus")
                print(f"   Confianca minima: {default_config['min_confidence']}%") 
                print(f"   Fluxo institucional: {default_config['institutional_weight_min']*100:.1f}%")
                print(f"   Baseado em: {optimized.get('baseado_em', 'dados historicos')}")
                
            except Exception as e:
                print(f"AVISO: Erro ao carregar config otimizada: {e}")
                print("Usando configuracao padrao")
        
        return default_config
        
    def _is_optimal_time(self):
        """Verifica se é um horário ótimo baseado na configuração (SEMPRE PERMITE TRADING)"""
        try:
            current_hour = datetime.now().hour
            
            # SEMPRE permitir trading - removida restrição de horários
            # Apenas retornar informação sobre se é horário ótimo ou não
            config_file = 'config_ml_amanha.json'
            if os.path.exists(config_file):
                import json
                with open(config_file, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                optimal_hours = config.get('parametros_otimizados', {}).get('horarios_preferenciais', [])
                if optimal_hours and current_hour in optimal_hours:
                    return True, f"Horário ótimo: {current_hour}h (baseado em dados históricos)"
                else:
                    return True, f"Horário permitido: {current_hour}h (fora do ótimo mas trading liberado)"
            
            # Sempre permitir trading independente do horário
            return True, f"Trading liberado: {current_hour}h"
            
        except Exception:
            return True, "Verificação de horário falhou - prosseguindo normalmente"
    
    def should_trade(self, regime_analysis, temp_analysis, fluxo_analysis, current_price, trades_data=None):
        """
        Determina se deve abrir uma posição baseado nas análises + Smart Money Consensus
        
        Args:
            regime_analysis: Análise do regime de mercado
            temp_analysis: Análise de temperatura  
            fluxo_analysis: Análise de fluxo
            current_price: Preço atual
            trades_data: Dados de trades para Smart Money analysis
            
        Returns:
            Dict com decisão de trading: {'action': 'BUY'/'SELL'/None, 'confidence': float, 'reason': str}
        """
        if not self.enabled:
            return {'action': None, 'confidence': 0, 'reason': 'Trading desabilitado'}
        
        # PRIMEIRA PRIORIDADE: Verificar stops das posições existentes
        # Nota: current_price já vem como parâmetro da função
        ticker = 'WINV25'  # Ticker correto do mini índice Bovespa
        if current_price:
            stop_decision = self.check_stop_orders(ticker, current_price)
            if stop_decision:
                return stop_decision
            
        # Verificar controle de risco básico - Reset diário
        current_date = datetime.now().date()
        if current_date != self.stats['last_trade_date']:
            self.stats['contracts_today'] = 0
            self.stats['last_trade_date'] = current_date
            
        if self.stats['contracts_today'] >= self.config['max_contracts_per_day']:
            return {'action': None, 'confidence': 0, 'reason': f'Limite de {self.config["max_contracts_per_day"]} contratos por dia atingido'}
            
        # Verificar horário ótimo (informativo apenas - não bloqueia trading)
        is_optimal, time_reason = self._is_optimal_time()
        # Removida restrição: trading permitido em qualquer horário
            
        # Extrair dados das análises
        regime = regime_analysis['regime']
        confidence = regime_analysis['confianca']
        temperatura = temp_analysis['temperatura_geral']['temperatura']
        institutional_pct = fluxo_analysis.get('percentual_institucional', 0)
        
        # Filtros básicos
        if confidence < self.config['min_confidence']:
            return {'action': None, 'confidence': confidence, 
                   'reason': f'Confiança baixa ({confidence}% < {self.config["min_confidence"]}%)'}
            
        if temperatura < self.config['min_temperature']:
            return {'action': None, 'confidence': confidence,
                   'reason': f'Mercado frio ({temperatura}° < {self.config["min_temperature"]}°)'}
        
        # SMART MONEY ANALYSIS - Nova prioridade máxima!
        smart_consensus = None
        if trades_data:
            smart_consensus = calcular_smart_money_consensus(trades_data)
            smart_score = get_smart_money_score(smart_consensus)
            
            # Se Smart Money tem sinal forte, seguir independente do regime!
            if smart_consensus['smart_money_signal'] in ['COMPRA', 'VENDA']:
                if smart_consensus['confidence'] > 75:
                    action = 'BUY' if smart_consensus['smart_money_signal'] == 'COMPRA' else 'SELL'
                    
                    # Mostrar líderes institucionais
                    leaders = ", ".join([f"{l['nome']}" for l in smart_consensus['leading_institutions'][:2]])
                    
                    return {
                        'action': action,
                        'confidence': smart_consensus['confidence'],
                        'reason': f'SMART MONEY: {smart_consensus['consensus_strength']:.1f}% consenso {smart_consensus['smart_money_signal']} (Líderes: {leaders})',
                        'stop_loss': current_price * (1 - self.config['stop_loss_pct']) if action == 'BUY' else current_price * (1 + self.config['stop_loss_pct']),
                        'take_profit': current_price * (1 + self.config['take_profit_pct']) if action == 'BUY' else current_price * (1 - self.config['take_profit_pct']),
                        'smart_money_analysis': smart_consensus
                    }
        
        # Regras de entrada baseadas no regime (usadas quando Smart Money não tem sinal forte)
        if regime == 'trending_bull':
            if institutional_pct >= self.config['institutional_weight_min'] * 100:
                return {
                    'action': 'BUY',
                    'confidence': confidence,
                    'reason': f'Bull trend c/ domínio institucional ({institutional_pct:.1f}%)',
                    'stop_loss': current_price * (1 - self.config['stop_loss_pct']),
                    'take_profit': current_price * (1 + self.config['take_profit_pct'])
                }
                
        elif regime == 'trending_bear':
            if institutional_pct >= self.config['institutional_weight_min'] * 100:
                return {
                    'action': 'SELL',
                    'confidence': confidence,
                    'reason': f'Bear trend c/ domínio institucional ({institutional_pct:.1f}%)',
                    'stop_loss': current_price * (1 + self.config['stop_loss_pct']),
                    'take_profit': current_price * (1 - self.config['take_profit_pct'])
                }
                
        elif regime == 'alta_volatilidade':
            # Em alta volatilidade, só entrar com confiança muito alta
            if confidence > 85:
                # Determinar direção pela temperatura e fluxo
                if temperatura > 20 and institutional_pct > 50:
                    return {
                        'action': 'BUY',
                        'confidence': confidence,
                        'reason': f'Volatilidade + temp alta ({temperatura}°)',
                        'stop_loss': current_price * (1 - self.config['stop_loss_pct'] * 0.7),  # Stop mais apertado
                        'take_profit': current_price * (1 + self.config['take_profit_pct'] * 0.7)
                    }
        
        return {'action': None, 'confidence': confidence, 'reason': f'Regime {regime} não atende critérios | {time_reason}'}
    
    def calculate_position_size(self, price, stop_loss_price):
        """
        Calcula o tamanho da posição baseado no risco
        
        Args:
            price: Preço de entrada
            stop_loss_price: Preço do stop loss
            
        Returns:
            Quantidade de contratos
        """
        risk_amount = self.current_capital * self.risk_per_trade
        price_risk = abs(price - stop_loss_price)
        
        if price_risk == 0:
            return 0
            
        quantity = int(risk_amount / price_risk)
        
        # Limitar pelo tamanho máximo da posição
        max_quantity = int((self.current_capital * self.max_position_size) / price)
        quantity = min(quantity, max_quantity)
        
        return max(1, quantity)  # Mínimo 1 contrato
    
    def place_order(self, ticker, side, price, decision):
        """
        Coloca uma ordem simulada
        
        Args:
            ticker: Nome do ativo
            side: 'BUY' ou 'SELL'
            price: Preço da ordem
            decision: Dict com decisão de trading
            
        Returns:
            SimulatedOrder ou None
        """
        if not self.enabled:
            return None
            
        # Calcular quantidade
        if decision.get('is_exit', False):
            # Para saída, usar quantidade especificada na decisão
            quantity = decision.get('quantity', 1)
        else:
            # Para entrada, calcular baseado no risco
            stop_price = decision.get('stop_loss', price)
            quantity = self.calculate_position_size(price, stop_price)
        
        if quantity <= 0:
            return None
            
        # Criar ordem
        order = SimulatedOrder(
            order_id=self.order_counter,
            ticker=ticker,
            side=side,
            price=price,
            quantity=quantity,
            timestamp=datetime.now(),
            strategy=f"Regime-{decision.get('reason', 'auto')}"
        )
        
        # Simular preenchimento imediato (market order)
        order.fill_order(price, datetime.now())
        
        self.orders[self.order_counter] = order
        self.order_counter += 1
        
        # Contar contratos apenas para entradas, não saídas
        if not decision.get('is_exit', False):
            self.stats['contracts_today'] += order.quantity
        
        # Atualizar posição
        self._update_position(order)
        
        # Configurar stops
        if 'stop_loss' in decision:
            self._set_stop_loss(order, decision['stop_loss'])
        if 'take_profit' in decision:
            self._set_take_profit(order, decision['take_profit'])
        
        return order
    
    def register_decision(self, decision_data):
        """Registra uma decisão de trading (executada ou não) para aprendizado"""
        self.decisions_history.append({
            **decision_data,
            'timestamp': datetime.now().isoformat()
        })
    
    def _update_position(self, order):
        """Atualiza posições com uma nova ordem"""
        ticker = order.ticker
        
        if ticker not in self.positions:
            self.positions[ticker] = {
                'side': 'LONG' if order.side == 'BUY' else 'SHORT',
                'quantity': 0,
                'avg_price': 0.0,
                'unrealized_pnl': 0.0,
                'orders': []
            }
        
        pos = self.positions[ticker]
        
        # Calcular nova média de preço
        if order.side == 'BUY':
            if pos['side'] == 'LONG' or pos['quantity'] == 0:
                total_cost = (pos['quantity'] * pos['avg_price']) + (order.quantity * order.fill_price)
                total_quantity = pos['quantity'] + order.quantity
                pos['avg_price'] = total_cost / total_quantity if total_quantity > 0 else 0
                pos['quantity'] = total_quantity
                pos['side'] = 'LONG'
            else:  # Fechando posição SHORT
                pos['quantity'] = max(0, pos['quantity'] - order.quantity)
                if pos['quantity'] == 0:
                    pos['side'] = 'FLAT'
        else:  # SELL
            if pos['side'] == 'SHORT' or pos['quantity'] == 0:
                total_cost = (pos['quantity'] * pos['avg_price']) + (order.quantity * order.fill_price)
                total_quantity = pos['quantity'] + order.quantity
                pos['avg_price'] = total_cost / total_quantity if total_quantity > 0 else 0
                pos['quantity'] = total_quantity
                pos['side'] = 'SHORT'
            else:  # Fechando posição LONG
                pos['quantity'] = max(0, pos['quantity'] - order.quantity)
                if pos['quantity'] == 0:
                    pos['side'] = 'FLAT'
        
        pos['orders'].append(order.order_id)
        
        # Adicionar à história de trades
        self.trades_history.append({
            'timestamp': order.fill_timestamp,
            'ticker': ticker,
            'side': order.side,
            'quantity': order.quantity,
            'price': order.fill_price,
            'strategy': order.strategy,
            'order_id': order.order_id
        })
    
    def _set_stop_loss(self, order, stop_price):
        """Define stop loss para uma ordem"""
        order.stop_loss = stop_price
        print(f"   🛑 Stop Loss definido: {stop_price:.2f}")
    
    def _set_take_profit(self, order, tp_price):
        """Define take profit para uma ordem"""
        order.take_profit = tp_price
        print(f"   🎯 Take Profit definido: {tp_price:.2f}")
    
    def check_stop_orders(self, ticker, current_price):
        """
        Verifica se alguma posição deve ser fechada por stop loss ou take profit
        
        Args:
            ticker: Nome do ativo
            current_price: Preço atual
            
        Returns:
            dict: Decisão de fechamento se houver
        """
        if ticker not in self.positions:
            return None
            
        pos = self.positions[ticker]
        if pos['quantity'] == 0:
            return None
        
        # Verificar ordens com stop loss ou take profit
        for order_id in pos['orders']:
            if order_id in self.orders:
                order = self.orders[order_id]
                if order.status != 'FILLED':
                    continue
                
                # Verificar stop loss
                if hasattr(order, 'stop_loss') and order.stop_loss:
                    stop_triggered = False
                    if order.side == 'BUY' and current_price <= order.stop_loss:
                        stop_triggered = True
                    elif order.side == 'SELL' and current_price >= order.stop_loss:
                        stop_triggered = True
                        
                    if stop_triggered:
                        return {
                            'action': 'SELL' if order.side == 'BUY' else 'BUY',
                            'confidence': 100,
                            'reason': f'Stop Loss atingido ({current_price:.2f} vs {order.stop_loss:.2f})',
                            'quantity': pos['quantity'],
                            'is_exit': True
                        }
                
                # Verificar take profit
                if hasattr(order, 'take_profit') and order.take_profit:
                    tp_triggered = False
                    if order.side == 'BUY' and current_price >= order.take_profit:
                        tp_triggered = True
                    elif order.side == 'SELL' and current_price <= order.take_profit:
                        tp_triggered = True
                        
                    if tp_triggered:
                        return {
                            'action': 'SELL' if order.side == 'BUY' else 'BUY', 
                            'confidence': 100,
                            'reason': f'Take Profit atingido ({current_price:.2f} vs {order.take_profit:.2f})',
                            'quantity': pos['quantity'],
                            'is_exit': True
                        }
        
        return None
    
    def update_positions(self, ticker, current_price):
        """
        Atualiza PnL das posições e verifica stops
        
        Args:
            ticker: Nome do ativo
            current_price: Preço atual
        """
        if ticker not in self.positions:
            return
            
        pos = self.positions[ticker]
        if pos['quantity'] == 0:
            return
            
        # Calcular PnL não realizado
        if pos['side'] == 'LONG':
            pos['unrealized_pnl'] = pos['quantity'] * (current_price - pos['avg_price'])
        elif pos['side'] == 'SHORT':
            pos['unrealized_pnl'] = pos['quantity'] * (pos['avg_price'] - current_price)
        else:
            pos['unrealized_pnl'] = 0.0
        
        # Verificar stops (simplificado)
        for order_id in pos['orders']:
            if order_id in self.orders:
                order = self.orders[order_id]
                if order.status == 'FILLED':
                    # Aqui verificaríamos stops reais
                    pass
    
    def get_portfolio_summary(self):
        """Retorna resumo do portfólio"""
        total_unrealized = sum(pos['unrealized_pnl'] for pos in self.positions.values())
        
        return {
            'initial_capital': self.initial_capital,
            'current_capital': self.current_capital + total_unrealized,
            'unrealized_pnl': total_unrealized,
            'total_return': ((self.current_capital + total_unrealized) / self.initial_capital - 1) * 100,
            'active_positions': len([p for p in self.positions.values() if p['quantity'] > 0]),
            'total_trades': len(self.trades_history),
            'win_rate': (self.stats['winning_trades'] / max(1, self.stats['total_trades'])) * 100
        }
    
    def print_portfolio_status(self):
        """Imprime status atual do portfólio"""
        summary = self.get_portfolio_summary()
        
        print(f"\n{'='*60}")
        print(f"{'💼 STATUS DO PORTFÓLIO SIMULADO':^60}")
        print(f"{'='*60}")
        
        print(f"💰 Capital Inicial:    R$ {summary['initial_capital']:>12,.2f}")
        print(f"💳 Capital Atual:      R$ {summary['current_capital']:>12,.2f}")
        print(f"📊 PnL Não Realizado: R$ {summary['unrealized_pnl']:>12,.2f}")
        print(f"📈 Retorno Total:      {summary['total_return']:>12.2f}%")
        
        print(f"\n📋 Estatísticas:")
        print(f"   Posições Ativas:   {summary['active_positions']:>6}")
        print(f"   Total de Trades:   {summary['total_trades']:>6}")
        print(f"   Taxa de Acerto:    {summary['win_rate']:>6.1f}%")
        print(f"   Contratos Hoje:    {self.stats['contracts_today']:>6}")
        
        # Mostrar posições ativas
        active_positions = {k: v for k, v in self.positions.items() if v['quantity'] > 0}
        if active_positions:
            print(f"\n🎯 POSIÇÕES ATIVAS:")
            for ticker, pos in active_positions.items():
                pnl_emoji = "📈" if pos['unrealized_pnl'] >= 0 else "📉"
                print(f"   {pnl_emoji} {ticker}: {pos['side']} {pos['quantity']} @ {pos['avg_price']:.2f} "
                      f"| PnL: R$ {pos['unrealized_pnl']:,.2f}")
        
        print(f"{'='*60}")
    
    def save_trading_results(self, session_id):
        """Salva os resultados de trading simulado para aprendizado do ML"""
        if not self.trades_history and not self.decisions_history:
            return
        
        from pathlib import Path
        import json
        import pandas as pd
        from datetime import datetime
        
        # Criar diretório para dados de trading simulado
        trading_path = Path("data") / "trading_results" / session_id
        trading_path.mkdir(parents=True, exist_ok=True)
        
        # Salvar histórico de trades executados
        if self.trades_history:
            trades_df = pd.DataFrame(self.trades_history)
            trades_file = trading_path / "simulated_trades.csv"
            trades_df.to_csv(trades_file, index=False)
            
        # Salvar histórico de decisões (incluindo as não executadas)
        if self.decisions_history:
            decisions_file = trading_path / "trading_decisions.json"
            with open(decisions_file, 'w', encoding='utf-8') as f:
                json.dump(self.decisions_history, f, indent=2, default=str)
        
        # Salvar estatísticas de performance
        performance_data = {
            'session_id': session_id,
            'timestamp': datetime.now().isoformat(),
            'initial_capital': self.initial_capital,
            'current_capital': self.current_capital,
            'stats': self.stats,
            'config': self.config,
            'portfolio_summary': self.get_portfolio_summary()
        }
        
        performance_file = trading_path / "performance_summary.json"
        with open(performance_file, 'w', encoding='utf-8') as f:
            json.dump(performance_data, f, indent=2, default=str)
            
        print(f"📊 Dados de trading simulado salvos em: {trading_path}")

# ============================================================================
# CLASSE PRINCIPAL DO MONITOR
# ============================================================================

class ProfitDLLMonitor:
    def __init__(self, dll_path="./ProfitDLL.dll"):
        """
        Inicializa o monitor da ProfitDLL
        
        Args:
            dll_path: Caminho para a DLL (ProfitDLL64.dll para 64 bits ou ProfitDLL.dll para 32 bits)
        """
        self.dll = None
        self.connected = False
        self.trade_data = defaultdict(lambda: {
            'volume_compra_agressor': 0.0,
            'volume_venda_agressor': 0.0,
            'qtd_compra_agressor': 0,
            'qtd_venda_agressor': 0,
            'total_trades': 0
        })
        self.data_lock = Lock()
        
        # Sistema de Temperatura do Mercado
        self.historico_temperatura = []
        self.temperatura_anterior = None
        self.max_historico_temp = 20  # Manter últimas 20 leituras
        
        # Sistema de Janela Deslizante para Temperatura (NOVO!)
        self.trade_timestamps = []  # Lista de timestamps dos trades
        self.trade_volumes = []     # Lista de volumes correspondentes
        self.temp_window_minutes = 5  # Janela de 5 minutos para temperatura
        
        # Sistema de Classificação de Regimes
        self.historico_regimes = []
        self.regime_atual = None
        self.regime_anterior = None
        self.max_historico_regimes = 10  # Manter últimos 10 regimes
        
        # Sistema de Coleta de Dados
        self.data_collector = DataCollector()
        
        # Sistema de Trading Automático Simulado
        self.trading_engine = TradingEngine(initial_capital=100000.0)  # R$ 100k inicial
        self.current_price = {}  # ticker -> preço atual
        self.trading_decisions_history = []
        self.last_trading_check = time.time()
        self.trading_check_interval = 15  # Verificar decisões a cada 15 segundos
        
        # Configurar callbacks
        self.trade_callback = TNewTradeCallback(self._on_new_trade)
        
        try:
            self.dll = ctypes.CDLL(dll_path)
            self._setup_functions()
        except OSError as e:
            print(f"Erro ao carregar a DLL: {e}")
            raise

    def _setup_functions(self):
        """Configura as funções da DLL com os tipos corretos"""
        
        # DLLInitializeLogin
        self.dll.DLLInitializeLogin.argtypes = [
            c_wchar_p,  # activation_key
            c_wchar_p,  # user
            c_wchar_p,  # password
            TStateCallback,  # state_callback
            c_void_p,  # history_callback
            c_void_p,  # order_change_callback
            TAccountCallback,  # account_callback
            TNewTradeCallback,  # new_trade_callback
            c_void_p,  # new_daily_callback
            c_void_p,  # price_book_callback
            c_void_p,  # offer_book_callback
            c_void_p,  # history_trade_callback
            TProgressCallback,  # progress_callback
            TTinyBookCallback   # tiny_book_callback
        ]
        self.dll.DLLInitializeLogin.restype = c_int
        
        # SubscribeTicker
        self.dll.SubscribeTicker.argtypes = [c_wchar_p, c_wchar_p]
        self.dll.SubscribeTicker.restype = c_int
        
        # DLLFinalize
        self.dll.DLLFinalize.argtypes = []
        self.dll.DLLFinalize.restype = c_int

    def connect(self, activation_key, username, password):
        """
        Conecta à ProfitDLL
        
        Args:
            activation_key: Chave de ativação fornecida
            username: Nome de usuário
            password: Senha
        """
        try:
            result = self.dll.DLLInitializeLogin(
                activation_key,
                username, 
                password,
                state_callback,
                None,  # history_callback
                None,  # order_change_callback  
                account_callback,
                self.trade_callback,
                None,  # new_daily_callback
                None,  # price_book_callback
                None,  # offer_book_callback
                None,  # history_trade_callback
                progress_callback,
                tiny_book_callback
            )
            
            if result == 0:  # NL_OK
                self.connected = True
                print("Conectado com sucesso à ProfitDLL!")
                return True
            else:
                print(f"Erro na conexão. Código: {result}")
                return False
                
        except Exception as e:
            print(f"Erro durante a conexão: {e}")
            return False

    def _on_new_trade(self, asset_id, date_str, trade_number, price, volume, 
                     quantity, buy_agent, sell_agent, trade_type, is_edit):
        """
        Callback chamado quando há um novo trade
        
        Args:
            asset_id: Identificação do ativo
            date_str: Data/hora do trade
            trade_number: Número do trade
            price: Preço
            volume: Volume financeiro
            quantity: Quantidade
            buy_agent: Agente comprador (ID da corretora)
            sell_agent: Agente vendedor (ID da corretora)
            trade_type: Tipo do trade (1=Cross, 2=Compra agressão, 3=Venda agressão, etc.)
            is_edit: Se é uma edição
        """
        try:
            with self.data_lock:
                ticker = asset_id.pwcTicker if asset_id.pwcTicker else "UNKNOWN"
                
                # ATUALIZAR PREÇO ATUAL PARA O TRADING ENGINE
                self.current_price[ticker] = price
                
                # ADICIONAR À JANELA DESLIZANTE DE TEMPERATURA (NOVO!)
                self._add_trade_to_window(quantity)
                
                # Determinar se é trade agressor e por qual corretora
                if trade_type == 2:  # Compra agressão
                    corretora_id = buy_agent
                    self.trade_data[corretora_id]['volume_compra_agressor'] += volume
                    self.trade_data[corretora_id]['qtd_compra_agressor'] += quantity
                elif trade_type == 3:  # Venda agressão  
                    corretora_id = sell_agent
                    self.trade_data[corretora_id]['volume_venda_agressor'] += volume
                    self.trade_data[corretora_id]['qtd_venda_agressor'] += quantity
                
                # Atualizar estatísticas gerais para ambas as corretoras
                for corretora in [buy_agent, sell_agent]:
                    if corretora != 0:  # 0 indica corretora não identificada
                        self.trade_data[corretora]['total_trades'] += 1
                
                # COLETAR DADOS - Todos os trades para ML
                self.data_collector.collect_trade(asset_id, price, volume, quantity, 
                                                 buy_agent, sell_agent, trade_type)
                
                # Filtro: mostrar apenas trades com quantidade > 100
                if quantity > 100:
                    # Obter informações das corretoras
                    info_comprador = get_corretora_info(buy_agent)
                    info_vendedor = get_corretora_info(sell_agent)
                    
                    # Determinar se é um trade importante (institucional ou corretoras mapeadas)
                    is_important = (info_comprador and info_comprador['categoria'] == 'institucional') or \
                                 (info_vendedor and info_vendedor['categoria'] == 'institucional') or \
                                 buy_agent in [3, 85] or sell_agent in [3, 85]
                    
                    if is_important:
                        # Trade importante - log detalhado
                        comprador_nome = get_corretora_nome_display(buy_agent)
                        vendedor_nome = get_corretora_nome_display(sell_agent)
                        
                        # Emojis baseados na categoria
                        emoji_comprador = get_emoji_by_categoria(get_corretora_categoria(buy_agent))
                        emoji_vendedor = get_emoji_by_categoria(get_corretora_categoria(sell_agent))
                        
                        print(f"🎯 TRADE RELEVANTE: {ticker} | Preço: {price:.2f} | Qtd: {quantity}")
                        print(f"   {emoji_comprador} Comprador: {comprador_nome}")
                        print(f"   {emoji_vendedor} Vendedor: {vendedor_nome}")
                        print(f"   Tipo: {self._get_trade_type_name(trade_type)}")
                        
                        # Peso do trade baseado nas corretoras envolvidas
                        peso_comprador = get_corretora_peso(buy_agent)
                        peso_vendedor = get_corretora_peso(sell_agent)
                        peso_medio = (peso_comprador + peso_vendedor) / 2
                        if peso_medio > 1.3:
                            print(f"   ⚡ ALTO IMPACTO (peso {peso_medio:.1f})")
                        
                    else:
                        # Trade normal - log simples
                        print(f"Trade: {ticker} | {price:.2f} | Qtd: {quantity} | "
                              f"C: {get_corretora_nome_display(buy_agent)} | "
                              f"V: {get_corretora_nome_display(sell_agent)}")
                      
        except Exception as e:
            print(f"Erro no callback de trade: {e}")

    def _get_trade_type_name(self, trade_type):
        """Converte o código do tipo de trade para nome legível"""
        tipos = {
            1: "Cross trade",
            2: "Compra agressão", 
            3: "Venda agressão",
            4: "Leilão",
            5: "Surveillance",
            6: "Expit",
            7: "Options Exercise",
            8: "Over the counter",
            9: "Derivative Term",
            10: "Index",
            11: "BTC",
            12: "On Behalf", 
            13: "RLP",
            32: "Desconhecido"
        }
        return tipos.get(trade_type, f"Tipo {trade_type}")

    def subscribe_ticker(self, ticker, exchange="F"):
        """
        Inscreve-se para receber dados de um ativo
        
        Args:
            ticker: Nome do ativo (ex: "WINV25")
            exchange: Bolsa (padrão "B" para Bovespa)
        """
        if not self.connected:
            print("Não conectado! Execute connect() primeiro.")
            return False
            
        try:
            result = self.dll.SubscribeTicker(ticker, exchange)
            if result == 0:  # NL_OK
                print(f"Inscrito com sucesso no ativo {ticker}")
                return True
            else:
                print(f"Erro ao se inscrever no ativo {ticker}. Código: {result}")
                return False
        except Exception as e:
            print(f"Erro ao se inscrever no ativo: {e}")
            return False

    def get_corretora_stats(self, corretora_id):
        """
        Obtém estatísticas de uma corretora específica
        
        Args:
            corretora_id: ID da corretora
            
        Returns:
            Dict com estatísticas da corretora
        """
        with self.data_lock:
            if corretora_id in self.trade_data:
                stats = self.trade_data[corretora_id].copy()
                
                # Calcular totais
                stats['volume_total_agressor'] = (stats['volume_compra_agressor'] + 
                                                 stats['volume_venda_agressor'])
                stats['qtd_total_agressor'] = (stats['qtd_compra_agressor'] + 
                                             stats['qtd_venda_agressor'])
                
                return stats
            else:
                return None

    def get_all_stats(self):
        """Obtém estatísticas de todas as corretoras"""
        with self.data_lock:
            return dict(self.trade_data)

    def get_fluxo_analysis(self):
        """
        Análise de fluxo por categoria de corretora
        
        Returns:
            Dict com análise completa do fluxo de mercado
        """
        all_stats = self.get_all_stats()
        
        # Calcular volume total agressor para cada corretora
        for corretora_id in all_stats:
            stats = all_stats[corretora_id]
            stats['volume_total_agressor'] = (stats['volume_compra_agressor'] + 
                                            stats['volume_venda_agressor'])
        
        # Usar função utilitária para calcular score
        fluxo_score = calcular_score_fluxo(all_stats)
        
        # Adicionar informações extras
        fluxo_score['timestamp'] = datetime.now()
        fluxo_score['total_corretoras'] = len(all_stats)
        fluxo_score['corretoras_mapeadas'] = sum(1 for cid in all_stats.keys() if get_corretora_info(cid) is not None)
        
        return fluxo_score

    def get_top_corretoras_by_categoria(self, categoria='todas', limit=5):
        """
        Obtém top corretoras por categoria
        
        Args:
            categoria: 'institucional', 'varejo', 'outros' ou 'todas'
            limit: Número máximo de corretoras
            
        Returns:
            Lista de corretoras ordenadas por volume
        """
        all_stats = self.get_all_stats()
        
        # Filtrar por categoria se especificada
        if categoria != 'todas':
            filtered_stats = {}
            for corretora_id, stats in all_stats.items():
                if get_corretora_categoria(corretora_id) == categoria:
                    filtered_stats[corretora_id] = stats
        else:
            filtered_stats = all_stats
        
        # Calcular volume total e ordenar
        top_list = []
        for corretora_id, stats in filtered_stats.items():
            volume_total = stats['volume_compra_agressor'] + stats['volume_venda_agressor']
            if volume_total > 0:  # Apenas corretoras com volume
                info = get_corretora_info(corretora_id)
                top_list.append({
                    'corretora_id': corretora_id,
                    'nome': info['nome'] if info else f'ID {corretora_id}',
                    'categoria': info['categoria'] if info else 'desconhecida',
                    'peso': info['peso'] if info else 1.0,
                    'volume_total': volume_total,
                    'volume_compra': stats['volume_compra_agressor'],
                    'volume_venda': stats['volume_venda_agressor'],
                    'qtd_total': stats['qtd_compra_agressor'] + stats['qtd_venda_agressor'],
                    'total_trades': stats['total_trades']
                })
        
        # Ordenar por volume total (decrescente)
        top_list.sort(key=lambda x: x['volume_total'], reverse=True)
        
        return top_list[:limit]


    def print_mapeamento_corretoras(self):
        """Imprime o mapeamento atual de corretoras conhecidas"""
        print(f"\n{'='*80}")
        print(f"{'MAPEAMENTO DE CORRETORAS':^80}")
        print(f"{'='*80}")
        
        # Agrupar por categoria
        por_categoria = {'institucional': [], 'varejo': [], 'outros': []}
        
        for nome, config in CORRETORAS_CONFIG.items():
            categoria = config['categoria']
            if categoria in por_categoria:
                por_categoria[categoria].append({
                    'nome': nome,
                    'nome_completo': config['nome_completo'],
                    'peso': config['peso'],
                    'ids': config['ids']
                })
        
        # Imprimir cada categoria
        for categoria, corretoras in por_categoria.items():
            emoji = get_emoji_by_categoria(categoria)
            print(f"\n{emoji} {categoria.upper()}:")
            
            for corretora in sorted(corretoras, key=lambda x: x['peso'], reverse=True):
                ids_str = ', '.join(map(str, corretora['ids'])) if corretora['ids'] else 'não mapeada'
                print(f"   • {corretora['nome']} (peso {corretora['peso']}) - IDs: {ids_str}")
                print(f"     {corretora['nome_completo']}")
        
        print(f"\nTotal de corretoras mapeadas: {len(ID_TO_CORRETORA)} IDs")
        print(f"{'='*80}")

    def print_fluxo_analysis(self):
        """Imprime análise completa do fluxo de mercado"""
        fluxo = self.get_fluxo_analysis()
        
        print(f"\n{'='*80}")
        print(f"{'ANÁLISE DE FLUXO DE MERCADO':^80}")
        print(f"{'='*80}")
        print(f"🕒 Timestamp: {fluxo['timestamp'].strftime('%H:%M:%S')}")
        print(f"📊 Total de corretoras ativas: {fluxo['total_corretoras']}")
        print(f"🗺️  Corretoras mapeadas: {fluxo['corretoras_mapeadas']}")
        
        print(f"\n💰 VOLUME POR CATEGORIA:")
        print(f"🏦 Institucional: R$ {fluxo['volume_institucional']:>15,.2f} "
              f"({fluxo['percentual_institucional']:>5.1f}%)")
        print(f"🏪 Varejo:        R$ {fluxo['volume_varejo']:>15,.2f} "
              f"({fluxo['percentual_varejo']:>5.1f}%)")
        print(f"🏢 Outros:        R$ {fluxo['volume_outros']:>15,.2f} "
              f"({fluxo['percentual_outros']:>5.1f}%)")
        
        print(f"\n⚖️  SCORE PONDERADO (com pesos):")
        print(f"🏦 Institucional: {fluxo['score_institucional']:>15,.0f}")
        print(f"🏪 Varejo:        {fluxo['score_varejo']:>15,.0f}")
        print(f"🏢 Outros:        {fluxo['score_outros']:>15,.0f}")
        
        # Determinar domínio
        dominio_emoji = '🏦' if fluxo['dominio'] == 'institucional' else \
                       '🏪' if fluxo['dominio'] == 'varejo' else '⚖️'
        
        print(f"\n{dominio_emoji} DOMÍNIO DE MERCADO: {fluxo['dominio'].upper()}")
        
        # SMART MONEY ANALYSIS (NOVO!)
        smart_consensus = calcular_smart_money_consensus(self.trade_data)
        if smart_consensus['total_institutions_active'] > 0:
            print(f"\n🧠 SMART MONEY CONSENSUS:")
            signal_emoji = "🟢" if smart_consensus['smart_money_signal'] == 'COMPRA' else "🔴" if smart_consensus['smart_money_signal'] == 'VENDA' else "🟡"
            print(f"   {signal_emoji} Sinal: {smart_consensus['smart_money_signal']} (Conf: {smart_consensus['confidence']:.1f}%)")
            print(f"   📊 Consenso: {smart_consensus['consensus_strength']:.1f}% {smart_consensus['consensus_direction']}")
            print(f"   🏦 Instituições ativas: {smart_consensus['total_institutions_active']}")
            print(f"   💰 Volume institucional: R$ {smart_consensus['total_institutional_volume']:,.2f}")
            
            # Mostrar líderes
            if smart_consensus['leading_institutions']:
                print(f"   👑 Líderes:")
                for i, leader in enumerate(smart_consensus['leading_institutions'][:3], 1):
                    bias_emoji = "📈" if leader['bias'] == 'COMPRA' else "📉"
                    print(f"      {i}. {leader['nome']} {bias_emoji} R$ {leader['volume_total']:,.0f}")
        else:
            print(f"\n🧠 SMART MONEY: Aguardando dados institucionais...")
        
        # Top corretoras por categoria
        print(f"\n🏆 TOP 3 POR CATEGORIA:")
        
        for categoria in ['institucional', 'varejo', 'outros']:
            top = self.get_top_corretoras_by_categoria(categoria, 3)
            emoji = get_emoji_by_categoria(categoria)
            print(f"\n{emoji} {categoria.title()}:")
            
            if top:
                for i, corr in enumerate(top, 1):
                    print(f"   {i}. {corr['nome']} - R$ {corr['volume_total']:,.0f} "
                          f"(peso {corr['peso']})")
            else:
                print("   (Nenhuma atividade detectada)")
        
        print(f"{'='*80}")

    def _add_trade_to_window(self, volume):
        """Adiciona trade à janela deslizante"""
        now = datetime.now()
        self.trade_timestamps.append(now)
        self.trade_volumes.append(volume)
        
        # Limpar dados antigos (fora da janela)
        cutoff_time = now - timedelta(minutes=self.temp_window_minutes)
        while self.trade_timestamps and self.trade_timestamps[0] < cutoff_time:
            self.trade_timestamps.pop(0)
            self.trade_volumes.pop(0)
    
    def _get_volume_in_window(self):
        """Obtém volume total na janela de tempo atual"""
        if not self.trade_volumes:
            return 0
        
        # Limpar dados antigos primeiro
        now = datetime.now()
        cutoff_time = now - timedelta(minutes=self.temp_window_minutes)
        while self.trade_timestamps and self.trade_timestamps[0] < cutoff_time:
            self.trade_timestamps.pop(0)
            self.trade_volumes.pop(0)
        
        return sum(self.trade_volumes)
    
    def calcular_temperatura_atual(self):
        """
        Calcula a temperatura atual do mercado baseada na JANELA DESLIZANTE (últimos 5 min)
        
        Returns:
            Dict com análise completa de temperatura
        """
        # NOVO: Usar janela deslizante em vez de acumulativo
        volume_janela = self._get_volume_in_window()
        
        # Análise de temperatura baseada na janela
        temp_info = calcular_temperatura_mercado(volume_janela)
        
        # Mudança de temperatura
        mudanca_info = get_mudanca_temperatura(
            temp_info['temperatura'], 
            self.temperatura_anterior
        )
        
        # Temperatura por categoria
        all_stats = self.get_all_stats()
        temp_por_categoria = analisar_temperatura_por_categoria(all_stats)
        
        # Análise completa
        analise_temp = {
            'timestamp': datetime.now(),
            'temperatura_geral': temp_info,
            'mudanca': mudanca_info,
            'por_categoria': temp_por_categoria,
            'volume_total_contratos': temp_info['volume_contratos']  # Usar volume da janela
        }
        
        # Adicionar ao histórico
        self.historico_temperatura.append(analise_temp)
        if len(self.historico_temperatura) > self.max_historico_temp:
            self.historico_temperatura = self.historico_temperatura[-self.max_historico_temp:]
        
        # Atualizar temperatura anterior
        self.temperatura_anterior = temp_info['temperatura']
        
        # COLETAR DADOS - Análise de temperatura para ML
        self.data_collector.collect_temperature_analysis(analise_temp)
        
        return analise_temp

    def print_analise_temperatura(self):
        """Imprime análise completa de temperatura do mercado"""
        analise = self.calcular_temperatura_atual()
        
        temp_geral = analise['temperatura_geral']
        mudanca = analise['mudanca']
        por_categoria = analise['por_categoria']
        
        print(f"\n{'='*80}")
        print(f"{'🌡️  ANÁLISE DE TEMPERATURA DO MERCADO':^80}")
        print(f"{'='*80}")
        
        # Temperatura geral
        print(f"🌡️  TEMPERATURA GERAL: {temp_geral['temperatura']}° {temp_geral['emoji']}")
        print(f"   Status: {temp_geral['classificacao'].upper()}")
        print(f"   {temp_geral['descricao']}")
        print(f"   Volume: {temp_geral['volume_contratos']:,} contratos")
        print(f"   ⏰ Janela: Últimos {self.temp_window_minutes} minutos (não acumulativo)")
        
        # Mudança de temperatura
        if mudanca['tendencia'] != 'inicial':
            print(f"\n🔄 MUDANÇA: {mudanca['emoji']} {mudanca['mudanca']:+.1f}° ({mudanca['percentual']:+.1f}%)")
            print(f"   Tendência: {mudanca['tendencia'].replace('_', ' ').title()}")
        
        # Temperatura por categoria
        print(f"\n🏛️  TEMPERATURA POR CATEGORIA:")
        
        categorias_ordenadas = ['institucional', 'varejo', 'outros', 'desconhecida']
        for categoria in categorias_ordenadas:
            info = por_categoria[categoria]
            temp_info = info['info']
            emoji_cat = get_emoji_by_categoria(categoria)
            
            # Só mostrar categoria se tiver volume > 0
            if info['volume'] > 0:
                print(f"{emoji_cat} {categoria.title():12}: {temp_info['temperatura']:>6.1f}° "
                      f"{temp_info['emoji']} | {info['volume']:>8,} contratos")
        
        # Alertas baseados na temperatura
        self._gerar_alertas_temperatura(analise)
        
        print(f"{'='*80}")

    def _gerar_alertas_temperatura(self, analise):
        """Gera alertas baseados na análise de temperatura"""
        temp_geral = analise['temperatura_geral']
        mudanca = analise['mudanca']
        por_categoria = analise['por_categoria']
        
        alertas = []
        
        # Alerta de mercado muito quente
        if temp_geral['temperatura'] > 25:
            alertas.append(f"🌋 MERCADO FERVENDO! Temperatura {temp_geral['temperatura']}° - MÁXIMA ATENÇÃO!")
        
        # Alerta de aquecimento rápido
        if mudanca['tendencia'] == 'aquecendo_rapido':
            alertas.append(f"🚨 AQUECIMENTO RÁPIDO! +{mudanca['mudanca']}° em poucos minutos")
        
        # Alerta de desequilíbrio entre categorias
        temp_inst = por_categoria['institucional']['temperatura']
        temp_varejo = por_categoria['varejo']['temperatura']
        
        if temp_inst > 15 and temp_varejo < 5:
            alertas.append(f"⚡ DOMÍNIO INSTITUCIONAL! Inst: {temp_inst:.1f}° vs Varejo: {temp_varejo:.1f}°")
        elif temp_varejo > 15 and temp_inst < 5:
            alertas.append(f"🛍️ DOMÍNIO VAREJO! Varejo: {temp_varejo:.1f}° vs Inst: {temp_inst:.1f}°")
        
        # Mercado frio demais
        if temp_geral['temperatura'] < 3:
            alertas.append(f"🧊 MERCADO MUITO FRIO - Apenas {temp_geral['temperatura']}° de temperatura")
        
        # Imprimir alertas se houver
        if alertas:
            print(f"\n🚨 ALERTAS DE TEMPERATURA:")
            for alerta in alertas:
                print(f"   {alerta}")

    def get_historico_temperatura(self, limit=10):
        """
        Obtém histórico de temperatura
        
        Args:
            limit: Número de registros mais recentes
            
        Returns:
            Lista com histórico de temperatura
        """
        return self.historico_temperatura[-limit:] if self.historico_temperatura else []

    def classificar_regime_atual(self):
        """
        Classifica o regime atual do mercado usando todos os dados disponíveis
        
        Returns:
            Dict com classificação completa do regime
        """
        all_stats = self.get_all_stats()
        
        if not all_stats:
            return {
                'regime': 'sideways',
                'confianca': 30,
                'info': get_regime_info('sideways'),
                'gatilhos': ['Sem dados suficientes'],
                'stats': {},
                'timestamp': datetime.now()
            }
        
        # Obter análise de temperatura atual
        analise_temp = self.calcular_temperatura_atual()
        
        # Adicionar volume total agressor para cada corretora
        for corretora_id in all_stats:
            stats = all_stats[corretora_id]
            stats['volume_total_agressor'] = (stats['volume_compra_agressor'] + 
                                            stats['volume_venda_agressor'])
        
        # Classificar usando a função global
        regime_atual = classificar_regime_mercado(
            all_stats, 
            analise_temp, 
            self.historico_temperatura
        )
        
        # Detectar mudança de regime
        mudanca_regime = None
        if self.regime_atual and self.regime_atual['regime'] != regime_atual['regime']:
            mudanca_regime = {
                'de': self.regime_atual['regime'],
                'para': regime_atual['regime'],
                'timestamp': datetime.now(),
                'duracao_anterior': self._calcular_duracao_regime()
            }
        
        # Atualizar histórico
        self.regime_anterior = self.regime_atual
        self.regime_atual = regime_atual
        
        # Adicionar mudança ao resultado
        if mudanca_regime:
            regime_atual['mudanca'] = mudanca_regime
        
        # Adicionar ao histórico
        self.historico_regimes.append(regime_atual.copy())
        if len(self.historico_regimes) > self.max_historico_regimes:
            self.historico_regimes = self.historico_regimes[-self.max_historico_regimes:]
        
        # COLETAR DADOS - Análise de regime para ML
        self.data_collector.collect_regime_analysis(regime_atual)
        
        return regime_atual

    def _calcular_duracao_regime(self):
        """Calcula há quanto tempo o regime atual está ativo"""
        if not self.regime_atual:
            return 0
        
        agora = datetime.now()
        inicio_regime = self.regime_atual['timestamp']
        duracao = (agora - inicio_regime).total_seconds() / 60  # em minutos
        
        return round(duracao, 1)

    def print_analise_regime(self):
        """Imprime análise completa do regime de mercado"""
        regime = self.classificar_regime_atual()
        
        info = regime['info']
        confianca = regime['confianca']
        gatilhos = regime['gatilhos']
        stats = regime['stats']
        
        print(f"\n{'='*80}")
        print(f"{'📈 ANÁLISE DE REGIME DE MERCADO':^80}")
        print(f"{'='*80}")
        
        # Regime atual
        print(f"📈 REGIME ATUAL: {info['emoji']} {info['nome'].upper()}")
        print(f"   Confiança: {confianca}%")
        print(f"   {info['descricao']}")
        
        # Duração do regime
        duracao = self._calcular_duracao_regime()
        if duracao > 0:
            print(f"   Duração: {duracao} minutos")
        
        # Mudança de regime
        if 'mudanca' in regime:
            mudanca = regime['mudanca']
            info_anterior = get_regime_info(mudanca['de'])
            print(f"\n🔄 MUDANÇA DE REGIME: {info_anterior['emoji']} {mudanca['de']} → {info['emoji']} {mudanca['para']}")
            print(f"   Regime anterior durou: {mudanca['duracao_anterior']} minutos")
        
        # Gatilhos e estatísticas
        print(f"\n🎯 GATILHOS IDENTIFICADOS:")
        for gatilho in gatilhos:
            print(f"   • {gatilho}")
        
        # Estatísticas detalhadas
        if stats:
            print(f"\n📊 ESTATÍSTICAS:")
            if 'percentual_positivas' in stats:
                print(f"   Corretoras positivas: {stats['percentual_positivas']}%")
            if 'temperatura' in stats:
                print(f"   Temperatura mercado: {stats['temperatura']}°")
            if 'dominio' in stats:
                print(f"   Domínio de fluxo: {stats['dominio'].title()}")
            if 'volatilidade_score' in stats:
                print(f"   Score volatilidade: {stats['volatilidade_score']}/100")
        
        # Alertas baseados no regime
        self._gerar_alertas_regime(regime)
        
        print(f"{'='*80}")

    def _gerar_alertas_regime(self, regime):
        """Gera alertas baseados no regime atual"""
        alertas = []
        confianca = regime['confianca']
        regime_tipo = regime['regime']
        stats = regime.get('stats', {})
        
        # Alertas por tipo de regime
        if regime_tipo == 'trending_bull' and confianca > 80:
            alertas.append("🐂 FORTE TENDÊNCIA DE ALTA - Considere posições compradas")
        
        if regime_tipo == 'trending_bear' and confianca > 80:
            alertas.append("🐻 FORTE TENDÊNCIA DE BAIXA - Considere posições vendidas")
        
        if regime_tipo == 'alta_volatilidade' and confianca > 70:
            alertas.append("⚡ ALTA VOLATILIDADE - Cuidado com stops muito apertados")
        
        if regime_tipo == 'sideways' and stats.get('temperatura', 0) < 5:
            alertas.append("🧊 MERCADO MUITO PARADO - Aguarde breakout")
        
        # Alertas de mudança de regime
        if 'mudanca' in regime:
            mudanca = regime['mudanca']
            if mudanca['duracao_anterior'] < 2:
                alertas.append("🔄 MUDANÇA RÁPIDA DE REGIME - Mercado indeciso")
        
        # Alertas de confiança
        if confianca < 50:
            alertas.append("❓ BAIXA CONFIANÇA - Regime indefinido, aguarde confirmação")
        
        # Imprimir alertas
        if alertas:
            print(f"\n🚨 ALERTAS DE REGIME:")
            for alerta in alertas:
                print(f"   {alerta}")

    def get_historico_regimes(self, limit=5):
        """Obtém histórico de regimes"""
        return self.historico_regimes[-limit:] if self.historico_regimes else []
    
    def check_trading_opportunities(self):
        """
        Verifica oportunidades de trading baseado nas análises atuais
        
        Returns:
            List de decisões de trading tomadas
        """
        current_time = time.time()
        if current_time - self.last_trading_check < self.trading_check_interval:
            return []
            
        self.last_trading_check = current_time
        
        if not self.trading_engine.enabled:
            return []
        
        decisions_taken = []
        
        # Obter análises atuais
        all_stats = self.get_all_stats()
        if not all_stats:
            return []
            
        # Análises necessárias para decisão
        regime_analysis = self.classificar_regime_atual()
        temp_analysis = self.calcular_temperatura_atual()
        fluxo_analysis = self.get_fluxo_analysis()
        
        # Verificar cada ativo monitorado
        for ticker, current_price in self.current_price.items():
            if ticker == "UNKNOWN" or current_price <= 0:
                continue
                
            # Verificar se deve fazer uma decisão de trading (incluindo Smart Money analysis)
            decision = self.trading_engine.should_trade(
                regime_analysis, temp_analysis, fluxo_analysis, current_price, self.trade_data
            )
            
            # Log da decisão (sempre)
            decision_record = {
                'timestamp': datetime.now(),
                'ticker': ticker,
                'current_price': current_price,
                'regime': regime_analysis['regime'],
                'confidence': regime_analysis['confianca'],
                'temperature': temp_analysis['temperatura_geral']['temperatura'],
                'institutional_pct': fluxo_analysis.get('percentual_institucional', 0),
                'decision': decision['action'],
                'reason': decision['reason']
            }
            
            self.trading_decisions_history.append(decision_record)
            
            # Registrar decisão também no trading engine para salvamento
            self.trading_engine.register_decision(decision_record)
            
            # Executar ordem se decisão for BUY ou SELL
            if decision['action'] in ['BUY', 'SELL']:
                order = self.trading_engine.place_order(
                    ticker, decision['action'], current_price, decision
                )
                
                if order:
                    decisions_taken.append({
                        'decision_record': decision_record,
                        'order': order,
                        'regime_info': regime_analysis['info']
                    })
                    
                    # Log da ordem executada
                    regime_emoji = regime_analysis['info']['emoji']
                    action_emoji = "🟢" if decision['action'] == 'BUY' else "🔴"
                    
                    print(f"\n🤖 TRADING AUTOMÁTICO - ORDEM SIMULADA EXECUTADA!")
                    print(f"   {action_emoji} {decision['action']} {order.quantity} {ticker} @ {current_price:.2f}")
                    print(f"   {regime_emoji} Regime: {regime_analysis['regime']} (Conf: {regime_analysis['confianca']}%)")
                    print(f"   🌡️ Temperatura: {temp_analysis['temperatura_geral']['temperatura']}°")
                    print(f"   🏦 Fluxo Institucional: {fluxo_analysis.get('percentual_institucional', 0):.1f}%")
                    print(f"   💭 Motivo: {decision['reason']}")
                    
                    if 'stop_loss' in decision:
                        print(f"   🛑 Stop Loss: {decision['stop_loss']:.2f}")
                    if 'take_profit' in decision:
                        print(f"   🎯 Take Profit: {decision['take_profit']:.2f}")
                        
                    print(f"   📋 Estratégia: {order.strategy}")
            
            elif decision['confidence'] > 50:  # Log decisões de não-entrada com confiança média/alta
                print(f"\n🤖 Oportunidade Analisada - {ticker} @ {current_price:.2f}")
                print(f"   Decisão: AGUARDAR - {decision['reason']}")
                print(f"   Confiança: {decision['confidence']}% | Temp: {temp_analysis['temperatura_geral']['temperatura']}°")
        
        # Limitar histórico de decisões
        if len(self.trading_decisions_history) > 100:
            self.trading_decisions_history = self.trading_decisions_history[-100:]
        
        return decisions_taken
    
    def print_trading_summary(self):
        """Imprime resumo do sistema de trading automático"""
        if not hasattr(self, 'trading_engine'):
            print("Sistema de trading não inicializado")
            return
            
        print(f"\n{'='*80}")
        print(f"{'🤖 SISTEMA DE TRADING AUTOMÁTICO SIMULADO':^80}")
        print(f"{'='*80}")
        
        # Status do sistema
        status_emoji = "✅" if self.trading_engine.enabled else "❌"
        print(f"{status_emoji} Status: {'ATIVO' if self.trading_engine.enabled else 'DESABILITADO'}")
        
        # Configurações atuais
        config = self.trading_engine.config
        print(f"\n⚙️ CONFIGURAÇÕES:")
        print(f"   Confiança mínima: {config['min_confidence']}%")
        print(f"   Temperatura mínima: {config['min_temperature']}°")
        print(f"   Stop Loss: {config['stop_loss_pct']*100:.1f}%")
        print(f"   Take Profit: {config['take_profit_pct']*100:.1f}%")
        print(f"   Risco por trade: {self.trading_engine.risk_per_trade*100:.1f}%")
        print(f"   Max contratos/dia: {config['max_contracts_per_day']}")
        
        # Status do portfólio
        self.trading_engine.print_portfolio_status()
        
        # Últimas decisões
        if self.trading_decisions_history:
            print(f"\n📊 ÚLTIMAS ANÁLISES DE TRADING:")
            recent_decisions = self.trading_decisions_history[-5:]  # Últimas 5
            
            for i, decision in enumerate(recent_decisions, 1):
                action_emoji = "🟢" if decision['decision'] == 'BUY' else "🔴" if decision['decision'] == 'SELL' else "⚪"
                time_str = decision['timestamp'].strftime('%H:%M:%S')
                
                print(f"   {i}. {time_str} | {action_emoji} {decision['decision'] or 'HOLD'} {decision['ticker']} @ {decision['current_price']:.2f}")
                print(f"      {decision['reason'][:60]}...")
        
        print(f"{'='*80}")
    
    def enable_trading(self):
        """Ativa o sistema de trading automático"""
        self.trading_engine.enabled = True
        print("🟢 Sistema de trading automático ATIVADO")
        
    def disable_trading(self):
        """Desativa o sistema de trading automático"""  
        self.trading_engine.enabled = False
        print("🔴 Sistema de trading automático DESATIVADO")
        
    def configure_trading(self, **config_updates):
        """
        Atualiza configurações do sistema de trading
        
        Args:
            **config_updates: Parâmetros de configuração para atualizar
        """
        for key, value in config_updates.items():
            if key in self.trading_engine.config:
                old_value = self.trading_engine.config[key]
                self.trading_engine.config[key] = value
                print(f"⚙️ Configuração atualizada: {key}: {old_value} → {value}")
            else:
                print(f"❌ Configuração inválida: {key}")
    
    def get_trading_performance(self):
        """Retorna métricas de performance do trading"""
        if not hasattr(self, 'trading_engine'):
            return {}
            
        summary = self.trading_engine.get_portfolio_summary()
        
        # Adicionar métricas extras
        total_decisions = len(self.trading_decisions_history)
        executed_trades = len([d for d in self.trading_decisions_history if d['decision'] in ['BUY', 'SELL']])
        
        return {
            **summary,
            'total_decisions_analyzed': total_decisions,
            'executed_trades': executed_trades,
            'execution_rate': (executed_trades / max(1, total_decisions)) * 100,
            'decisions_per_hour': total_decisions / max(1, (time.time() - self.last_trading_check) / 3600)
        }

    def print_corretora_summary(self, corretora_id):
        """Imprime um resumo das estatísticas de uma corretora"""
        stats = self.get_corretora_stats(corretora_id)
        
        if stats is None:
            print(f"Nenhum dado encontrado para a corretora {corretora_id}")
            return
            
        print(f"\n=== RESUMO CORRETORA {corretora_id} ===")
        print(f"Volume Compra Agressora: R$ {stats['volume_compra_agressor']:,.2f}")
        print(f"Volume Venda Agressora: R$ {stats['volume_venda_agressor']:,.2f}")
        print(f"Volume Total Agressor: R$ {stats['volume_total_agressor']:,.2f}")
        print(f"Quantidade Compra Agressora: {stats['qtd_compra_agressor']:,}")
        print(f"Quantidade Venda Agressora: {stats['qtd_venda_agressor']:,}")
        print(f"Quantidade Total Agressora: {stats['qtd_total_agressor']:,}")
        print(f"Total de Trades: {stats['total_trades']:,}")

    def print_xp_summary(self):
        """Imprime resumo específico da XP Investimentos (ID 3)"""
        all_stats = self.get_all_stats()
        
        print(f"\n{'='*60}")
        print(f"{'RESUMO XP INVESTIMENTOS (ID 3)':^60}")
        print(f"{'='*60}")
        
        if 3 in all_stats:
            stats = all_stats[3]
            volume_total = stats['volume_compra_agressor'] + stats['volume_venda_agressor']
            qtd_total = stats['qtd_compra_agressor'] + stats['qtd_venda_agressor']
            
            print(f"🎯 XP Investimentos (ID 3): Vol. R$ {volume_total:>12,.2f} | "
                  f"Qtd: {qtd_total:>8,} | Trades: {stats['total_trades']:>6,}")
            print(f"   📈 Vol. Compra Agressora: R$ {stats['volume_compra_agressor']:>12,.2f}")
            print(f"   📉 Vol. Venda Agressora:  R$ {stats['volume_venda_agressor']:>12,.2f}")
            print(f"   🔢 Qtd. Compra Agressora: {stats['qtd_compra_agressor']:>8,}")
            print(f"   🔢 Qtd. Venda Agressora:  {stats['qtd_venda_agressor']:>8,}")
        else:
            print("⚠️  Nenhum trade da XP detectado ainda.")
    
    def print_all_summary(self):
        """Imprime resumo de todas as corretoras"""
        all_stats = self.get_all_stats()
        
        if not all_stats:
            print("Nenhum dado de trade disponível ainda.")
            return
            
        print(f"\n{'='*60}")
        print(f"{'RESUMO GERAL - TODAS CORRETORAS':^60}")
        print(f"{'='*60}")
        
        for corretora_id in sorted(all_stats.keys()):
            stats = all_stats[corretora_id]
            volume_total = stats['volume_compra_agressor'] + stats['volume_venda_agressor']
            qtd_total = stats['qtd_compra_agressor'] + stats['qtd_venda_agressor']
            
            # Destaca XP (ID 3) e corretora 85
            if corretora_id == 3:
                prefix = "🎯"
            elif corretora_id == 85:
                prefix = "🔥"
            else:
                prefix = "  "
            
            print(f"{prefix} Corretora {corretora_id:>03}: Vol. Agressor: R$ {volume_total:>12,.2f} | "
                  f"Qtd: {qtd_total:>8,} | Trades: {stats['total_trades']:>6,}")

    def disconnect(self):
        """Desconecta da ProfitDLL"""
        if self.connected:
            try:
                self.dll.DLLFinalize()
                self.connected = False
                print("Desconectado da ProfitDLL")
            except Exception as e:
                print(f"Erro ao desconectar: {e}")


def load_credentials(file_path="credencial.txt"):
    """
    Carrega credenciais do arquivo de texto
    
    Formato esperado do arquivo credencial.txt:
    ACTIVATION_KEY=sua_chave_aqui
    USERNAME=seu_usuario_aqui
    PASSWORD=sua_senha_aqui
    CORRETORA_ALVO=123
    """
    credentials = {}
    
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                line = line.strip()
                if line and not line.startswith('#') and '=' in line:
                    key, value = line.split('=', 1)
                    credentials[key.strip()] = value.strip()
        
        # Verificar se todas as credenciais necessárias estão presentes
        required_fields = ['ACTIVATION_KEY', 'USERNAME', 'PASSWORD']
        missing_fields = [field for field in required_fields if field not in credentials]
        
        if missing_fields:
            print(f"Campos obrigatórios ausentes no arquivo {file_path}: {', '.join(missing_fields)}")
            return None
            
        # Converter CORRETORA_ALVO para inteiro se presente
        if 'CORRETORA_ALVO' in credentials:
            try:
                credentials['CORRETORA_ALVO'] = int(credentials['CORRETORA_ALVO'])
            except ValueError:
                print("Erro: CORRETORA_ALVO deve ser um número inteiro")
                return None
        else:
            credentials['CORRETORA_ALVO'] = 0  # Valor padrão
            
        return credentials
        
    except FileNotFoundError:
        print(f"Arquivo {file_path} não encontrado!")
        print("\nCrie o arquivo com o seguinte formato:")
        print("ACTIVATION_KEY=sua_chave_de_ativacao")
        print("USERNAME=seu_usuario")
        print("PASSWORD=sua_senha")
        print("CORRETORA_ALVO=123")
        return None
        
    except Exception as e:
        print(f"Erro ao ler arquivo de credenciais: {e}")
        return None


def main():
    """Exemplo de uso do monitor"""
    
    # Carregar credenciais do arquivo
    credentials = load_credentials()
    if not credentials:
        return
    
    ACTIVATION_KEY = credentials['ACTIVATION_KEY']
    USERNAME = credentials['USERNAME']
    PASSWORD = credentials['PASSWORD']
    CORRETORA_ALVO = credentials['CORRETORA_ALVO']
    
    # Ativos para monitorar - foco no WINV25 agora que está funcionando
    ATIVOS = ["WINV25"]
    
    monitor = None
    
    try:
        # Inicializar monitor
        print("Inicializando ProfitDLL Monitor...")
        monitor = ProfitDLLMonitor()
        
        # Conectar
        print("Conectando...")
        if not monitor.connect(ACTIVATION_KEY, USERNAME, PASSWORD):
            print("Falha na conexão!")
            return
            
        # Aguardar conexão estabilizar
        time.sleep(3)
        
        # Inscrever-se nos ativos
        print("Inscrevendo-se nos ativos...")
        for ativo in ATIVOS:
            # WINV25 é um futuro, deve usar exchange "F" (BMF/B3 Futuros)
            exchange = "F" if "WIN" in ativo.upper() else "B"
            monitor.subscribe_ticker(ativo, exchange)
            time.sleep(1)  # Pausa entre inscrições
            
        print(f"\n🚀 SISTEMA AVANÇADO DE MONITORAMENTO DE CORRETORAS")
        print(f"Corretora alvo: {CORRETORA_ALVO}")
        print(f"🔍 Filtro ativo: Trades > 100 contratos")
        print(f"🧠 Sistema inteligente: Análise de fluxo institucional/varejo ativo")
        print(f"🤖 Trading automático simulado: R$ {monitor.trading_engine.initial_capital:,.0f} capital inicial")
        
        # Mostrar mapeamento de corretoras no início
        monitor.print_mapeamento_corretoras()
        
        # Loop principal - monitora indefinidamente até interrupção manual
        start_time = time.time()
        last_summary = time.time()
        
        print(f"🔄 Sistema rodando... Pressione Ctrl+C para parar e gerar relatório final")
        
        while True:  # Loop infinito até Ctrl+C
            time.sleep(10)  # Aguarda 10 segundos
            
            # Mostra resumo a cada 15 segundos
            if time.time() - last_summary >= 15:
                print(f"\n--- {datetime.now().strftime('%H:%M:%S')} ---")
                
                # VERIFICAR OPORTUNIDADES DE TRADING (NOVO!)
                trading_decisions = monitor.check_trading_opportunities()
                
                # Análise de regime de mercado (NOVA - FASE 2!)
                regime_analysis = monitor.classificar_regime_atual()
                monitor.print_analise_regime()
                
                # Análise de temperatura (FASE 1)
                temp_analysis = monitor.calcular_temperatura_atual()
                monitor.print_analise_temperatura()
                
                # Análise de fluxo (FASE 3)
                fluxo_analysis = monitor.get_fluxo_analysis()
                monitor.print_fluxo_analysis()
                
                # SISTEMA DE TRADING AUTOMÁTICO - RESUMO (NOVO!)
                if hasattr(monitor, 'trading_engine'):
                    monitor.print_trading_summary()
                
                # COLETAR SNAPSHOT COMPLETO DO MERCADO
                all_stats = monitor.get_all_stats()
                monitor.data_collector.collect_market_snapshot(
                    all_stats, fluxo_analysis, temp_analysis, regime_analysis
                )
                
                last_summary = time.time()
        
        
    except KeyboardInterrupt:
        print("\n" + "="*80)
        print("⏹️  SISTEMA INTERROMPIDO PELO USUÁRIO")
        print("="*80)
        
        # Calcular tempo total de execução
        total_time = time.time() - start_time
        hours = int(total_time // 3600)
        minutes = int((total_time % 3600) // 60)
        seconds = int(total_time % 60)
        
        if hours > 0:
            time_str = f"{hours}h {minutes}m {seconds}s"
        elif minutes > 0:
            time_str = f"{minutes}m {seconds}s"
        else:
            time_str = f"{seconds}s"
        
        print(f"⏱️  Tempo total de coleta: {time_str}")
        print(f"📊 Sessão finalizada às: {datetime.now().strftime('%H:%M:%S')}")
        print("🔄 Gerando relatório final...")
        
        # Continuar para o relatório final mesmo após interrupção
        
    except Exception as e:
        print(f"Erro: {e}")
        
    finally:
        # GARANTIR QUE O RELATÓRIO FINAL SEJA SEMPRE GERADO
        if monitor:
            try:
                # Resumo final completo (mesmo código do sucesso)
                print(f"\n{'='*80}")
                print("📊 RESUMO FINAL DA SESSÃO")
                print(f"{'='*80}")
                
                # Análise final de regime (NOVA!)
                monitor.print_analise_regime()
                
                # Análise de temperatura final
                monitor.print_analise_temperatura()
                
                # Análise de fluxo final
                monitor.print_fluxo_analysis()
                
                # Histórico de regimes da sessão (NOVO!)
                historico_regimes = monitor.get_historico_regimes()
                if len(historico_regimes) > 1:
                    print(f"\n📈 EVOLUÇÃO DOS REGIMES NA SESSÃO:")
                    print(f"   Primeiro: {get_regime_info(historico_regimes[0]['regime'])['emoji']} {historico_regimes[0]['regime']}")
                    print(f"   Atual:    {get_regime_info(historico_regimes[-1]['regime'])['emoji']} {historico_regimes[-1]['regime']}")
                    
                    # Contar mudanças de regime
                    mudancas = 0
                    for i in range(1, len(historico_regimes)):
                        if historico_regimes[i]['regime'] != historico_regimes[i-1]['regime']:
                            mudancas += 1
                    
                    print(f"   Mudanças: {mudancas} | Análises: {len(historico_regimes)}")
                    
                    # Regime mais frequente
                    regimes_count = {}
                    for r in historico_regimes:
                        regime = r['regime']
                        regimes_count[regime] = regimes_count.get(regime, 0) + 1
                    
                    regime_dominante = max(regimes_count, key=regimes_count.get)
                    info_dominante = get_regime_info(regime_dominante)
                    print(f"   Dominante: {info_dominante['emoji']} {regime_dominante} ({regimes_count[regime_dominante]} análises)")

                # Histórico de temperatura da sessão
                historico = monitor.get_historico_temperatura()
                if len(historico) > 1:
                    print(f"\n🌡️ EVOLUÇÃO DA TEMPERATURA NA SESSÃO:")
                    print(f"   Início:  {historico[0]['temperatura_geral']['temperatura']}° {historico[0]['temperatura_geral']['emoji']}")
                    print(f"   Final:   {historico[-1]['temperatura_geral']['temperatura']}° {historico[-1]['temperatura_geral']['emoji']}")
                    
                    temp_max = max(h['temperatura_geral']['temperatura'] for h in historico)
                    temp_min = min(h['temperatura_geral']['temperatura'] for h in historico)
                    print(f"   Máxima: {temp_max}° | Mínima: {temp_min}°")
                    print(f"   Leituras: {len(historico)} registros")
                
                # Resumos específicos das corretoras principais
                print(f"\n[TARGET] DETALHES DAS CORRETORAS PRINCIPAIS:")
                monitor.print_xp_summary()  # XP ainda é importante
                if 85 in monitor.get_all_stats():  # Só mostra se tiver dados
                    monitor.print_corretora_summary(85)  # Morgan Stanley
                
                # Resumo geral por importância
                print(f"\n🏆 TOP CORRETORAS DA SESSÃO:")
                top_geral = monitor.get_top_corretoras_by_categoria('todas', 10)
                for i, corr in enumerate(top_geral, 1):
                    emoji = get_emoji_by_categoria(corr['categoria'])
                    print(f"{i:2d}. {emoji} {corr['nome']} - R$ {corr['volume_total']:>12,.0f} "
                          f"| Peso: {corr['peso']} | {corr['categoria'].title()}")
                
                # FINALIZAR COLETA DE DADOS E GERAR RELATÓRIO
                print(f"\n{'='*80}")
                print("💾 SISTEMA DE COLETA DE DADOS - RELATÓRIO FINAL")
                print(f"{'='*80}")
                
                # Exportar features para ML
                ml_features = monitor.data_collector.export_ml_features()
                
                # Salvar resultados de trading simulado
                if hasattr(monitor, 'trading_engine') and monitor.trading_engine:
                    monitor.trading_engine.save_trading_results(monitor.data_collector.session_id)
                
                # Gerar resumo da sessão
                session_summary = monitor.data_collector.generate_session_summary()
                
                print(f"📊 Sessão ID: {session_summary['session_id']}")
                print(f"📈 Trades coletados: {session_summary['total_trades_collected']:,}")
                print(f"🌡️ Análises de temperatura: {len(monitor.historico_temperatura)}")
                print(f"📈 Análises de regime: {session_summary['total_regimes_recorded']}")
                print(f"📸 Snapshots de mercado: {session_summary['total_snapshots']}")
                print(f"🧠 Features ML exportadas: {len(ml_features.get('temperature_series', []))}")
                
                # Adicionar estatísticas de trading simulado
                if hasattr(monitor, 'trading_engine') and monitor.trading_engine:
                    trading_stats = monitor.trading_engine.get_portfolio_summary()
                    print(f"🤖 Trading simulado - Decisões analisadas: {len(monitor.trading_engine.decisions_history)}")
                    print(f"🤖 Trading simulado - Operações executadas: {len(monitor.trading_engine.trades_history)}")
                    print(f"🤖 Trading simulado - Performance: {trading_stats['total_return']:.2f}%")
                
                print(f"\n[FILE] Arquivos gerados:")
                for file_type, file_path in session_summary['files_created'].items():
                    print(f"   {file_type.title()}: {file_path}")
                
                if ml_features.get('session_metadata'):
                    metadata = ml_features['session_metadata']
                    print(f"\n🎯 Estatísticas da sessão:")
                    print(f"   Duração estimada: {metadata.get('session_duration_minutes', 0):.1f} minutos")
                    print(f"   Total de amostras: {metadata.get('total_samples', 0)}")
                
                print(f"\n✅ Dados prontos para análise e machine learning!")
                print(f"[ML] Use os arquivos CSV/JSON para treinar modelos preditivos")
                print(f"{'='*80}")
                
            except Exception as e:
                print(f"Erro ao gerar relatório final: {e}")
            
            # Desconectar
            if monitor.connected:
                monitor.disconnect()


if __name__ == "__main__":
    main()