pattern_analysis.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Análise de Padrões Avançada - WINV25 Trading Data
Descobre padrões, correlações e insights nos dados coletados
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pathlib import Path
import json
import argparse
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

# Configurar estilo dos gráficos
plt.style.use('default')
sns.set_palette("husl")

class PatternAnalyzer:
    """Analisador avançado de padrões nos dados de trading"""
    
    def __init__(self, data_dir="./data"):
        """
        Inicializa o analisador
        
        Args:
            data_dir: Diretório com os dados coletados
        """
        self.data_dir = Path(data_dir)
        self.sessions = self._discover_sessions()
        
    def _discover_sessions(self):
        """Descobre sessões disponíveis"""
        sessions = {}
        trades_dir = self.data_dir / "trades"
        if trades_dir.exists():
            for file in trades_dir.glob("trades_*.csv"):
                session_id = file.stem.replace("trades_", "")
                sessions[session_id] = {'trades': file}
                
                # Adicionar outros arquivos da sessão
                for subdir in ['regimes', 'temperature', 'snapshots']:
                    json_file = self.data_dir / subdir / f"{subdir}_{session_id}.json"
                    if json_file.exists():
                        sessions[session_id][subdir] = json_file
        
        return sessions
    
    def load_session_data(self, session_id):
        """Carrega dados completos de uma sessão"""
        if session_id not in self.sessions:
            available = list(self.sessions.keys())
            raise ValueError(f"Sessão {session_id} não encontrada. Disponíveis: {available}")
        
        session_data = {}
        files = self.sessions[session_id]
        
        # Carregar trades
        if 'trades' in files:
            df_trades = pd.read_csv(files['trades'])
            df_trades['timestamp'] = pd.to_datetime(df_trades['timestamp'], format='mixed')
            session_data['trades'] = df_trades
        
        # Carregar dados JSON
        for data_type in ['regimes', 'temperature', 'snapshots']:
            if data_type in files:
                with open(files[data_type], 'r', encoding='utf-8') as f:
                    session_data[data_type] = json.load(f)
        
        return session_data
    
    def analyze_session_patterns(self, session_id, save_plots=True):
        """
        Análise completa de padrões de uma sessão
        
        Args:
            session_id: ID da sessão
            save_plots: Se deve salvar gráficos
        """
        print(f"🔍 ANÁLISE DE PADRÕES - SESSÃO: {session_id}")
        print("="*80)
        
        data = self.load_session_data(session_id)
        
        if save_plots:
            # Criar diretório para plots
            plot_dir = Path(f"./plots_{session_id}")
            plot_dir.mkdir(exist_ok=True)
        
        # 1. Análise de Correlação Temperatura vs Atividade
        self._analyze_temperature_correlation(data, session_id, plot_dir if save_plots else None)
        
        # 2. Análise de Comportamento por Corretora
        self._analyze_broker_behavior(data, session_id, plot_dir if save_plots else None)
        
        # 3. Análise Temporal (Horários de Atividade)
        self._analyze_temporal_patterns(data, session_id, plot_dir if save_plots else None)
        
        # 4. Análise de Regimes de Mercado
        self._analyze_regime_patterns(data, session_id, plot_dir if save_plots else None)
        
        # 5. Análise de Fluxo Institucional vs Varejo
        self._analyze_flow_patterns(data, session_id, plot_dir if save_plots else None)
        
        # 6. Detecção de Anomalias
        self._detect_anomalies(data, session_id)
        
        if save_plots:
            print(f"\n📊 Gráficos salvos em: {plot_dir.absolute()}")
    
    def _analyze_temperature_correlation(self, data, session_id, plot_dir):
        """Analisa correlação entre temperatura e atividade do mercado"""
        print("\n🌡️ ANÁLISE: TEMPERATURA vs ATIVIDADE")
        print("-" * 50)
        
        if 'temperature' not in data or 'trades' not in data:
            print("❌ Dados insuficientes para análise de temperatura")
            return
        
        # Extrair dados de temperatura
        temp_data = []
        for t in data['temperature']:
            temp_data.append({
                'timestamp': pd.to_datetime(t['timestamp'], format='mixed'),
                'temperatura': t['temperatura_geral']['temperatura'],
                'classificacao': t['temperatura_geral']['classificacao'],
                'volume_contratos': t['volume_total_contratos']
            })
        
        df_temp = pd.DataFrame(temp_data)
        
        if len(df_temp) < 2:
            print("❌ Dados de temperatura insuficientes")
            return
        
        # Análise de trades por minuto
        df_trades = data['trades'].copy()
        df_trades['minute'] = df_trades['timestamp'].dt.floor('min')
        trades_per_minute = df_trades.groupby('minute').agg({
            'volume': 'sum',
            'quantity': 'sum',
            'trade_type': 'count'
        }).rename(columns={'trade_type': 'num_trades'})
        
        # Correlações
        if len(df_temp) > 1 and len(trades_per_minute) > 1:
            # Merge dados para correlação
            df_temp['minute'] = df_temp['timestamp'].dt.floor('min')
            merged = pd.merge(df_temp, trades_per_minute, on='minute', how='inner')
            
            if len(merged) > 1:
                corr_temp_vol = merged['temperatura'].corr(merged['volume'])
                corr_temp_qty = merged['temperatura'].corr(merged['quantity'])
                corr_temp_trades = merged['temperatura'].corr(merged['num_trades'])
                
                print(f"📊 Correlações descobertas:")
                print(f"   Temperatura vs Volume: {corr_temp_vol:.3f}")
                print(f"   Temperatura vs Quantidade: {corr_temp_qty:.3f}")
                print(f"   Temperatura vs Num.Trades: {corr_temp_trades:.3f}")
                
                # Interpretação
                if abs(corr_temp_vol) > 0.5:
                    trend = "forte" if abs(corr_temp_vol) > 0.7 else "moderada"
                    direction = "positiva" if corr_temp_vol > 0 else "negativa"
                    print(f"   💡 Correlação {trend} {direction} entre temperatura e volume!")
        
        # Análise por classificação de temperatura
        temp_stats = df_temp.groupby('classificacao').agg({
            'volume_contratos': ['mean', 'std', 'count']
        }).round(2)
        
        print(f"\n📈 Volume médio por temperatura:")
        for classificacao in ['fria', 'morna', 'quente', 'fervendo']:
            if classificacao in temp_stats.index:
                stats = temp_stats.loc[classificacao]
                mean_vol = stats[('volume_contratos', 'mean')]
                count = int(stats[('volume_contratos', 'count')])
                print(f"   {classificacao.title()}: {mean_vol:,.0f} contratos ({count} períodos)")
        
        # Gráfico se solicitado
        if plot_dir:
            self._plot_temperature_correlation(df_temp, merged if 'merged' in locals() else None, 
                                             plot_dir, session_id)
    
    def _analyze_broker_behavior(self, data, session_id, plot_dir):
        """Analisa comportamento individual das corretoras"""
        print("\n🏢 ANÁLISE: COMPORTAMENTO DAS CORRETORAS")
        print("-" * 50)
        
        if 'trades' not in data:
            print("❌ Dados de trades não disponíveis")
            return
        
        df_trades = data['trades'].copy()
        
        # Consolidar dados por corretora
        broker_stats = {}
        
        for _, row in df_trades.iterrows():
            # Processar comprador e vendedor
            for side, agent_col, cat_col, peso_col, nome_col in [
                ('buy', 'buy_agent', 'buy_categoria', 'buy_peso', 'buy_nome'),
                ('sell', 'sell_agent', 'sell_categoria', 'sell_peso', 'sell_nome')
            ]:
                agent_id = row[agent_col]
                if agent_id == 0:  # Ignorar IDs inválidos
                    continue
                
                if agent_id not in broker_stats:
                    broker_stats[agent_id] = {
                        'nome': row[nome_col],
                        'categoria': row[cat_col],
                        'peso': row[peso_col],
                        'volume_total': 0,
                        'quantidade_total': 0,
                        'num_trades': 0,
                        'volume_compra': 0,
                        'volume_venda': 0,
                        'horarios': [],
                        'precos': []
                    }
                
                # Atualizar estatísticas
                stats = broker_stats[agent_id]
                stats['volume_total'] += row['volume'] / 2  # Dividir por 2 pois cada trade conta duas vezes
                stats['quantidade_total'] += row['quantity'] / 2
                stats['num_trades'] += 0.5
                stats['horarios'].append(row['timestamp'])
                stats['precos'].append(row['price'])
                
                if side == 'buy':
                    stats['volume_compra'] += row['volume'] / 2
                else:
                    stats['volume_venda'] += row['volume'] / 2
        
        # Converter para DataFrame para análise
        broker_list = []
        for agent_id, stats in broker_stats.items():
            if stats['volume_total'] > 0:  # Só corretoras com atividade
                broker_list.append({
                    'agent_id': agent_id,
                    'nome': stats['nome'],
                    'categoria': stats['categoria'],
                    'peso': stats['peso'],
                    'volume_total': stats['volume_total'],
                    'quantidade_total': stats['quantidade_total'],
                    'num_trades': int(stats['num_trades']),
                    'volume_medio_trade': stats['volume_total'] / stats['num_trades'] if stats['num_trades'] > 0 else 0,
                    'bias_compra_venda': (stats['volume_compra'] - stats['volume_venda']) / stats['volume_total'] if stats['volume_total'] > 0 else 0,
                    'preco_medio': np.mean(stats['precos']) if stats['precos'] else 0,
                    'volatilidade_preco': np.std(stats['precos']) if len(stats['precos']) > 1 else 0,
                    'duracao_atividade': (max(stats['horarios']) - min(stats['horarios'])).total_seconds() / 60 if len(stats['horarios']) > 1 else 0
                })
        
        df_brokers = pd.DataFrame(broker_list)
        if df_brokers.empty:
            print("❌ Nenhuma atividade de corretora detectada")
            return
        
        # Top corretoras por volume
        print("🏆 TOP 10 CORRETORAS POR VOLUME:")
        top_brokers = df_brokers.nlargest(10, 'volume_total')
        for i, row in top_brokers.iterrows():
            categoria_emoji = {'institucional': '🏦', 'varejo': '🏪', 'outros': '🏢'}.get(row['categoria'], '❓')
            print(f"   {categoria_emoji} {row['nome']} - R$ {row['volume_total']:>12,.0f} | "
                  f"Peso: {row['peso']} | {int(row['num_trades'])} trades")
        
        # Análise por categoria
        print(f"\n📊 ANÁLISE POR CATEGORIA:")
        for categoria in ['institucional', 'varejo', 'outros']:
            cat_brokers = df_brokers[df_brokers['categoria'] == categoria]
            if not cat_brokers.empty:
                total_vol = cat_brokers['volume_total'].sum()
                num_brokers = len(cat_brokers)
                avg_vol = cat_brokers['volume_total'].mean()
                avg_bias = cat_brokers['bias_compra_venda'].mean()
                
                print(f"   {categoria.title()}:")
                print(f"      Volume total: R$ {total_vol:,.0f} ({len(cat_brokers)} corretoras)")
                print(f"      Volume médio: R$ {avg_vol:,.0f}")
                print(f"      Bias C/V: {avg_bias:+.2f} (+ = mais compra)")
        
        # Detectar comportamentos interessantes
        self._detect_broker_anomalies(df_brokers)
        
        # Salvar gráfico se solicitado
        if plot_dir:
            self._plot_broker_analysis(df_brokers, plot_dir, session_id)
    
    def _analyze_temporal_patterns(self, data, session_id, plot_dir):
        """Analisa padrões temporais (horários de atividade)"""
        print("\n⏰ ANÁLISE: PADRÕES TEMPORAIS")
        print("-" * 50)
        
        if 'trades' not in data:
            print("❌ Dados de trades não disponíveis")
            return
        
        df_trades = data['trades'].copy()
        
        # Extrair componentes de tempo
        df_trades['hora'] = df_trades['timestamp'].dt.hour
        df_trades['minuto'] = df_trades['timestamp'].dt.minute
        df_trades['segundo'] = df_trades['timestamp'].dt.second
        df_trades['hora_decimal'] = df_trades['hora'] + df_trades['minuto']/60 + df_trades['segundo']/3600
        
        # Análise por hora
        hourly_stats = df_trades.groupby('hora').agg({
            'volume': ['sum', 'mean', 'count'],
            'quantity': ['sum', 'mean'],
            'price': ['mean', 'std']
        }).round(2)
        
        print("📈 ATIVIDADE POR HORA:")
        for hora in sorted(df_trades['hora'].unique()):
            if hora in hourly_stats.index:
                vol_total = hourly_stats.loc[hora, ('volume', 'sum')]
                num_trades = hourly_stats.loc[hora, ('volume', 'count')]
                preco_medio = hourly_stats.loc[hora, ('price', 'mean')]
                
                print(f"   {hora:02d}:00 - Volume: R$ {vol_total:>8,.0f} | "
                      f"{num_trades:>3} trades | Preço médio: {preco_medio:.3f}")
        
        # Detectar horários de pico
        hourly_volume = df_trades.groupby('hora')['volume'].sum()
        hora_pico = hourly_volume.idxmax()
        vol_pico = hourly_volume.max()
        
        print(f"\n🔥 HORÁRIO DE PICO: {hora_pico:02d}:00 (R$ {vol_pico:,.0f})")
        
        # Análise de 5 em 5 minutos
        df_trades['intervalo_5min'] = (df_trades['minuto'] // 5) * 5
        interval_stats = df_trades.groupby('intervalo_5min')['volume'].agg(['sum', 'count']).round(2)
        
        print(f"\n📊 ATIVIDADE POR INTERVALO DE 5 MINUTOS:")
        for intervalo in sorted(df_trades['intervalo_5min'].unique()):
            if intervalo in interval_stats.index:
                vol = interval_stats.loc[intervalo, 'sum']
                count = interval_stats.loc[intervalo, 'count']
                print(f"   {intervalo:02d}-{(intervalo+4):02d}min: R$ {vol:>8,.0f} ({count} trades)")
        
        # Detectar padrões de concentração
        hora_concentracao = len(df_trades['hora'].unique())
        minuto_concentracao = len(df_trades['minuto'].unique())
        
        print(f"\n⏱️  CONCENTRAÇÃO TEMPORAL:")
        print(f"   Ativo em {hora_concentracao} horas diferentes")
        print(f"   Ativo em {minuto_concentracao} minutos diferentes")
        
        if hora_concentracao <= 2:
            print("   💡 Atividade muito concentrada em poucas horas!")
        elif minuto_concentracao <= 10:
            print("   💡 Atividade concentrada em poucos minutos!")
        
        # Salvar gráfico se solicitado
        if plot_dir:
            self._plot_temporal_patterns(df_trades, hourly_stats, plot_dir, session_id)
    
    def _analyze_regime_patterns(self, data, session_id, plot_dir):
        """Analisa padrões nos regimes de mercado"""
        print("\n📈 ANÁLISE: PADRÕES DE REGIMES")
        print("-" * 50)
        
        if 'regimes' not in data:
            print("❌ Dados de regime não disponíveis")
            return
        
        regime_data = data['regimes']
        
        if len(regime_data) < 2:
            print("❌ Dados de regime insuficientes")
            return
        
        # Processar dados de regime
        df_regimes = pd.DataFrame([{
            'timestamp': pd.to_datetime(r['timestamp'], format='mixed'),
            'regime': r['regime'],
            'confianca': r['confianca'],
            'temp_mercado': r['stats'].get('temperatura', 0) if 'stats' in r else 0,
            'pct_positivas': r['stats'].get('percentual_positivas', 0) if 'stats' in r else 0,
            'pct_institucional': r['stats'].get('percentual_institucional', 0) if 'stats' in r else 0,
            'dominio': r['stats'].get('dominio', 'indefinido') if 'stats' in r else 'indefinido'
        } for r in regime_data])
        
        # Análise de distribuição de regimes
        regime_counts = df_regimes['regime'].value_counts()
        print("📊 DISTRIBUIÇÃO DE REGIMES:")
        regime_emojis = {
            'trending_bull': '🐂',
            'trending_bear': '🐻', 
            'sideways': '↔️',
            'alta_volatilidade': '⚡'
        }
        
        for regime, count in regime_counts.items():
            pct = (count / len(df_regimes)) * 100
            emoji = regime_emojis.get(regime, '❓')
            print(f"   {emoji} {regime}: {count} ({pct:.1f}%)")
        
        # Análise de transições
        transitions = []
        for i in range(1, len(df_regimes)):
            prev_regime = df_regimes.iloc[i-1]['regime']
            curr_regime = df_regimes.iloc[i]['regime']
            if prev_regime != curr_regime:
                transitions.append((prev_regime, curr_regime))
        
        if transitions:
            print(f"\n🔄 MUDANÇAS DE REGIME ({len(transitions)} transições):")
            from collections import Counter
            transition_counts = Counter(transitions)
            for (from_regime, to_regime), count in transition_counts.most_common():
                emoji_from = regime_emojis.get(from_regime, '❓')
                emoji_to = regime_emojis.get(to_regime, '❓')
                print(f"   {emoji_from} {from_regime} → {emoji_to} {to_regime}: {count}x")
        
        # Análise de confiança por regime
        print(f"\n🎯 CONFIANÇA MÉDIA POR REGIME:")
        confidence_by_regime = df_regimes.groupby('regime')['confianca'].agg(['mean', 'std']).round(1)
        for regime in confidence_by_regime.index:
            mean_conf = confidence_by_regime.loc[regime, 'mean']
            std_conf = confidence_by_regime.loc[regime, 'std']
            emoji = regime_emojis.get(regime, '❓')
            print(f"   {emoji} {regime}: {mean_conf}% (±{std_conf}%)")
        
        # Correlação regime vs métricas
        if len(df_regimes) > 2:
            print(f"\n📊 CORRELAÇÕES COM MÉTRICAS:")
            print(f"   Confiança vs Temp.Mercado: {df_regimes['confianca'].corr(df_regimes['temp_mercado']):.3f}")
            print(f"   Confiança vs % Positivas: {df_regimes['confianca'].corr(df_regimes['pct_positivas']):.3f}")
            print(f"   Temp vs % Institucional: {df_regimes['temp_mercado'].corr(df_regimes['pct_institucional']):.3f}")
        
        # Salvar gráfico se solicitado
        if plot_dir:
            self._plot_regime_patterns(df_regimes, plot_dir, session_id)
    
    def _analyze_flow_patterns(self, data, session_id, plot_dir):
        """Analisa padrões de fluxo institucional vs varejo"""
        print("\n🌊 ANÁLISE: PADRÕES DE FLUXO")
        print("-" * 50)
        
        if 'snapshots' not in data:
            print("❌ Dados de snapshots não disponíveis")
            return
        
        snapshots = data['snapshots']
        
        if len(snapshots) < 2:
            print("❌ Snapshots insuficientes para análise")
            return
        
        # Extrair dados de fluxo
        flow_data = []
        for snapshot in snapshots:
            flow_data.append({
                'timestamp': pd.to_datetime(snapshot['timestamp'], format='mixed'),
                'volume_total': snapshot['market_stats']['volume_total'],
                'contratos_total': snapshot['market_stats']['contratos_total'],
                'pct_institucional': snapshot['fluxo']['percentual_institucional'],
                'pct_varejo': snapshot['fluxo']['percentual_varejo'],
                'pct_outros': snapshot['fluxo']['percentual_outros'],
                'dominio': snapshot['fluxo']['dominio'],
                'temperatura': snapshot['temperatura']['temperatura_geral']['temperatura'],
                'regime': snapshot['regime']['regime']
            })
        
        df_flow = pd.DataFrame(flow_data)
        
        # Análise de domínio
        dominio_counts = df_flow['dominio'].value_counts()
        print("👑 DOMÍNIO DE MERCADO:")
        dominio_emojis = {'institucional': '🏦', 'varejo': '🏪', 'equilibrado': '⚖️'}
        
        for dominio, count in dominio_counts.items():
            pct = (count / len(df_flow)) * 100
            emoji = dominio_emojis.get(dominio, '❓')
            print(f"   {emoji} {dominio.title()}: {count} períodos ({pct:.1f}%)")
        
        # Análise estatística dos fluxos
        print(f"\n📊 ESTATÍSTICAS DE FLUXO:")
        print(f"   Institucional - Média: {df_flow['pct_institucional'].mean():.1f}% | "
              f"Desvio: ±{df_flow['pct_institucional'].std():.1f}%")
        print(f"   Varejo - Média: {df_flow['pct_varejo'].mean():.1f}% | "
              f"Desvio: ±{df_flow['pct_varejo'].std():.1f}%")
        print(f"   Outros - Média: {df_flow['pct_outros'].mean():.1f}% | "
              f"Desvio: ±{df_flow['pct_outros'].std():.1f}%")
        
        # Detectar extremos
        max_inst = df_flow['pct_institucional'].max()
        max_varejo = df_flow['pct_varejo'].max()
        
        print(f"\n🔥 EXTREMOS DETECTADOS:")
        print(f"   Maior domínio institucional: {max_inst:.1f}%")
        print(f"   Maior domínio varejo: {max_varejo:.1f}%")
        
        if max_inst > 60:
            print("   💡 Forte pressão institucional detectada!")
        if max_varejo > 40:
            print("   💡 Forte atividade de varejo detectada!")
        
        # Correlação fluxo vs temperatura
        if len(df_flow) > 2:
            corr_inst_temp = df_flow['pct_institucional'].corr(df_flow['temperatura'])
            corr_varejo_temp = df_flow['pct_varejo'].corr(df_flow['temperatura'])
            
            print(f"\n🌡️ CORRELAÇÃO COM TEMPERATURA:")
            print(f"   Institucional vs Temp: {corr_inst_temp:+.3f}")
            print(f"   Varejo vs Temp: {corr_varejo_temp:+.3f}")
            
            if abs(corr_inst_temp) > 0.5:
                direction = "positiva" if corr_inst_temp > 0 else "negativa"
                print(f"   💡 Correlação {direction} forte entre fluxo institucional e temperatura!")
        
        # Salvar gráfico se solicitado
        if plot_dir:
            self._plot_flow_patterns(df_flow, plot_dir, session_id)
    
    def _detect_anomalies(self, data, session_id):
        """Detecta anomalias e padrões incomuns"""
        print("\n🚨 DETECÇÃO DE ANOMALIAS")
        print("-" * 50)
        
        anomalies_found = []
        
        # 1. Anomalias de volume
        if 'trades' in data:
            df_trades = data['trades']
            
            # Trades muito grandes
            volume_threshold = df_trades['volume'].quantile(0.95)
            big_trades = df_trades[df_trades['volume'] > volume_threshold]
            
            if len(big_trades) > 0:
                anomalies_found.append(f"💰 {len(big_trades)} trades com volume > R$ {volume_threshold:,.0f}")
                
                # Maior trade
                biggest_trade = big_trades.loc[big_trades['volume'].idxmax()]
                anomalies_found.append(f"   🔥 Maior trade: R$ {biggest_trade['volume']:,.0f} às {biggest_trade['timestamp'].strftime('%H:%M:%S')}")
        
        # 2. Anomalias de temperatura
        if 'temperature' in data and len(data['temperature']) > 2:
            temperatures = [t['temperatura_geral']['temperatura'] for t in data['temperature']]
            temp_mean = np.mean(temperatures)
            temp_std = np.std(temperatures)
            
            # Temperaturas extremas (2 desvios padrão)
            temp_threshold = temp_mean + 2 * temp_std
            extreme_temps = [t for t in temperatures if t > temp_threshold]
            
            if extreme_temps:
                anomalies_found.append(f"🌡️ {len(extreme_temps)} períodos com temperatura extrema (>{temp_threshold:.1f}°)")
        
        # 3. Anomalias de regime
        if 'regimes' in data and len(data['regimes']) > 3:
            regimes = [r['regime'] for r in data['regimes']]
            confidences = [r['confianca'] for r in data['regimes']]
            
            # Confiança muito baixa
            low_confidence = [c for c in confidences if c < 40]
            if low_confidence:
                anomalies_found.append(f"❓ {len(low_confidence)} análises com baixa confiança (<40%)")
            
            # Mudanças muito frequentes
            changes = sum(1 for i in range(1, len(regimes)) if regimes[i] != regimes[i-1])
            if changes > len(regimes) * 0.5:  # Mais de 50% de mudanças
                anomalies_found.append(f"🔄 Mercado muito instável: {changes} mudanças de regime")
        
        # 4. Anomalias de corretora
        if 'trades' in data:
            # Corretora com atividade concentrada
            broker_activity = data['trades'].groupby('buy_agent')['volume'].sum()
            total_volume = broker_activity.sum()
            
            for agent_id, volume in broker_activity.items():
                if volume / total_volume > 0.3:  # Mais de 30% do volume total
                    agent_name = data['trades'][data['trades']['buy_agent'] == agent_id]['buy_nome'].iloc[0]
                    pct = (volume / total_volume) * 100
                    anomalies_found.append(f"🏢 {agent_name} concentra {pct:.1f}% do volume total")
        
        # Mostrar anomalias encontradas
        if anomalies_found:
            print("⚠️  ANOMALIAS DETECTADAS:")
            for i, anomaly in enumerate(anomalies_found, 1):
                print(f"   {i}. {anomaly}")
        else:
            print("✅ Nenhuma anomalia significativa detectada")
    
    def _detect_broker_anomalies(self, df_brokers):
        """Detecta anomalias específicas no comportamento das corretoras"""
        print(f"\n🕵️ ANOMALIAS DE COMPORTAMENTO:")
        
        anomalies = []
        
        # Corretora com bias extremo (só compra ou só venda)
        extreme_bias = df_brokers[abs(df_brokers['bias_compra_venda']) > 0.8]
        for _, broker in extreme_bias.iterrows():
            bias = broker['bias_compra_venda']
            direction = "APENAS COMPRA" if bias > 0.8 else "APENAS VENDA" if bias < -0.8 else "NEUTRO"
            anomalies.append(f"{broker['nome']}: {direction} (bias: {bias:+.2f})")
        
        # Corretora com volume médio muito alto
        high_vol_threshold = df_brokers['volume_medio_trade'].quantile(0.9)
        high_vol_brokers = df_brokers[df_brokers['volume_medio_trade'] > high_vol_threshold]
        for _, broker in high_vol_brokers.iterrows():
            vol = broker['volume_medio_trade']
            anomalies.append(f"{broker['nome']}: Volume médio muito alto (R$ {vol:,.0f}/trade)")
        
        # Mostrar anomalias
        if anomalies:
            for anomaly in anomalies[:5]:  # Mostrar apenas top 5
                print(f"   ⚠️  {anomaly}")
        else:
            print("   ✅ Comportamento normal das corretoras")
    
    # Métodos de plotagem (placeholder - podem ser expandidos)
    def _plot_temperature_correlation(self, df_temp, merged, plot_dir, session_id):
        """Plota correlação temperatura vs atividade"""
        try:
            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
            fig.suptitle(f'Análise de Temperatura - Sessão {session_id}', fontsize=16)
            
            # Plot 1: Temperatura ao longo do tempo
            axes[0,0].plot(df_temp['timestamp'], df_temp['temperatura'])
            axes[0,0].set_title('Temperatura ao Longo do Tempo')
            axes[0,0].set_ylabel('Temperatura (°)')
            
            # Plot 2: Distribuição por classificação
            temp_counts = df_temp['classificacao'].value_counts()
            axes[0,1].bar(temp_counts.index, temp_counts.values)
            axes[0,1].set_title('Distribuição por Classificação')
            axes[0,1].set_ylabel('Frequência')
            
            # Plot 3: Volume vs Temperatura (se dados disponíveis)
            if merged is not None and len(merged) > 1:
                axes[1,0].scatter(merged['temperatura'], merged['volume'])
                axes[1,0].set_title('Volume vs Temperatura')
                axes[1,0].set_xlabel('Temperatura (°)')
                axes[1,0].set_ylabel('Volume (R$)')
            
            # Plot 4: Box plot temperatura por classificação
            if len(df_temp) > 1:
                df_temp.boxplot(column='temperatura', by='classificacao', ax=axes[1,1])
                axes[1,1].set_title('Temperatura por Classificação')
            
            plt.tight_layout()
            plt.savefig(plot_dir / f'temperature_analysis_{session_id}.png', dpi=300, bbox_inches='tight')
            plt.close()
            
        except Exception as e:
            print(f"Erro ao criar gráfico de temperatura: {e}")
    
    def _plot_broker_analysis(self, df_brokers, plot_dir, session_id):
        """Plota análise de corretoras"""
        try:
            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
            fig.suptitle(f'Análise de Corretoras - Sessão {session_id}', fontsize=16)
            
            # Plot 1: Top 10 por volume
            top10 = df_brokers.nlargest(10, 'volume_total')
            axes[0,0].barh(range(len(top10)), top10['volume_total'])
            axes[0,0].set_yticks(range(len(top10)))
            axes[0,0].set_yticklabels([nome[:15] + '...' if len(nome) > 15 else nome 
                                     for nome in top10['nome']], fontsize=8)
            axes[0,0].set_title('Top 10 Corretoras por Volume')
            axes[0,0].set_xlabel('Volume (R$)')
            
            # Plot 2: Distribuição por categoria
            cat_counts = df_brokers['categoria'].value_counts()
            axes[0,1].pie(cat_counts.values, labels=cat_counts.index, autopct='%1.1f%%')
            axes[0,1].set_title('Distribuição por Categoria')
            
            # Plot 3: Bias Compra/Venda
            axes[1,0].hist(df_brokers['bias_compra_venda'], bins=20)
            axes[1,0].set_title('Distribuição de Bias Compra/Venda')
            axes[1,0].set_xlabel('Bias (-1=só venda, +1=só compra)')
            axes[1,0].set_ylabel('Frequência')
            
            # Plot 4: Volume vs Número de Trades
            axes[1,1].scatter(df_brokers['num_trades'], df_brokers['volume_total'])
            axes[1,1].set_title('Volume vs Número de Trades')
            axes[1,1].set_xlabel('Número de Trades')
            axes[1,1].set_ylabel('Volume Total (R$)')
            
            plt.tight_layout()
            plt.savefig(plot_dir / f'broker_analysis_{session_id}.png', dpi=300, bbox_inches='tight')
            plt.close()
            
        except Exception as e:
            print(f"Erro ao criar gráfico de corretoras: {e}")
    
    def _plot_temporal_patterns(self, df_trades, hourly_stats, plot_dir, session_id):
        """Plota padrões temporais"""
        try:
            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
            fig.suptitle(f'Padrões Temporais - Sessão {session_id}', fontsize=16)
            
            # Plot 1: Volume por hora
            axes[0,0].bar(hourly_stats.index, hourly_stats[('volume', 'sum')])
            axes[0,0].set_title('Volume por Hora')
            axes[0,0].set_xlabel('Hora')
            axes[0,0].set_ylabel('Volume (R$)')
            
            # Plot 2: Número de trades por hora
            axes[0,1].bar(hourly_stats.index, hourly_stats[('volume', 'count')])
            axes[0,1].set_title('Número de Trades por Hora')
            axes[0,1].set_xlabel('Hora')
            axes[0,1].set_ylabel('Número de Trades')
            
            # Plot 3: Preço médio por hora
            axes[1,0].plot(hourly_stats.index, hourly_stats[('price', 'mean')])
            axes[1,0].set_title('Preço Médio por Hora')
            axes[1,0].set_xlabel('Hora')
            axes[1,0].set_ylabel('Preço Médio')
            
            # Plot 4: Timeline dos trades
            axes[1,1].scatter(df_trades['timestamp'], df_trades['price'], alpha=0.6, s=10)
            axes[1,1].set_title('Timeline dos Trades')
            axes[1,1].set_xlabel('Horário')
            axes[1,1].set_ylabel('Preço')
            
            plt.tight_layout()
            plt.savefig(plot_dir / f'temporal_patterns_{session_id}.png', dpi=300, bbox_inches='tight')
            plt.close()
            
        except Exception as e:
            print(f"Erro ao criar gráfico temporal: {e}")
    
    def _plot_regime_patterns(self, df_regimes, plot_dir, session_id):
        """Plota padrões de regime"""
        try:
            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
            fig.suptitle(f'Padrões de Regime - Sessão {session_id}', fontsize=16)
            
            # Plot 1: Timeline de regimes
            regime_colors = {
                'trending_bull': 'green',
                'trending_bear': 'red', 
                'sideways': 'blue',
                'alta_volatilidade': 'orange'
            }
            
            for i, regime in enumerate(df_regimes['regime'].unique()):
                mask = df_regimes['regime'] == regime
                axes[0,0].scatter(df_regimes[mask]['timestamp'], [i]*sum(mask), 
                                 label=regime, color=regime_colors.get(regime, 'gray'))
            axes[0,0].set_title('Timeline de Regimes')
            axes[0,0].set_ylabel('Regime')
            axes[0,0].legend()
            
            # Plot 2: Distribuição de regimes
            regime_counts = df_regimes['regime'].value_counts()
            axes[0,1].pie(regime_counts.values, labels=regime_counts.index, autopct='%1.1f%%')
            axes[0,1].set_title('Distribuição de Regimes')
            
            # Plot 3: Confiança vs Temperatura
            axes[1,0].scatter(df_regimes['temp_mercado'], df_regimes['confianca'])
            axes[1,0].set_title('Confiança vs Temperatura')
            axes[1,0].set_xlabel('Temperatura (°)')
            axes[1,0].set_ylabel('Confiança (%)')
            
            # Plot 4: Confiança por regime
            df_regimes.boxplot(column='confianca', by='regime', ax=axes[1,1])
            axes[1,1].set_title('Confiança por Regime')
            
            plt.tight_layout()
            plt.savefig(plot_dir / f'regime_patterns_{session_id}.png', dpi=300, bbox_inches='tight')
            plt.close()
            
        except Exception as e:
            print(f"Erro ao criar gráfico de regimes: {e}")
    
    def _plot_flow_patterns(self, df_flow, plot_dir, session_id):
        """Plota padrões de fluxo"""
        try:
            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
            fig.suptitle(f'Padrões de Fluxo - Sessão {session_id}', fontsize=16)
            
            # Plot 1: Evolução dos fluxos
            axes[0,0].plot(df_flow['timestamp'], df_flow['pct_institucional'], label='Institucional')
            axes[0,0].plot(df_flow['timestamp'], df_flow['pct_varejo'], label='Varejo')
            axes[0,0].plot(df_flow['timestamp'], df_flow['pct_outros'], label='Outros')
            axes[0,0].set_title('Evolução dos Fluxos')
            axes[0,0].set_ylabel('Percentual (%)')
            axes[0,0].legend()
            
            # Plot 2: Distribuição de domínio
            dominio_counts = df_flow['dominio'].value_counts()
            axes[0,1].pie(dominio_counts.values, labels=dominio_counts.index, autopct='%1.1f%%')
            axes[0,1].set_title('Distribuição de Domínio')
            
            # Plot 3: Fluxo Institucional vs Temperatura
            axes[1,0].scatter(df_flow['temperatura'], df_flow['pct_institucional'])
            axes[1,0].set_title('Fluxo Institucional vs Temperatura')
            axes[1,0].set_xlabel('Temperatura (°)')
            axes[1,0].set_ylabel('% Institucional')
            
            # Plot 4: Comparação Institucional vs Varejo
            axes[1,1].scatter(df_flow['pct_institucional'], df_flow['pct_varejo'])
            axes[1,1].set_title('Institucional vs Varejo')
            axes[1,1].set_xlabel('% Institucional')
            axes[1,1].set_ylabel('% Varejo')
            axes[1,1].plot([0, 100], [100, 0], 'r--', alpha=0.5)  # Linha diagonal
            
            plt.tight_layout()
            plt.savefig(plot_dir / f'flow_patterns_{session_id}.png', dpi=300, bbox_inches='tight')
            plt.close()
            
        except Exception as e:
            print(f"Erro ao criar gráfico de fluxo: {e}")
    
    def compare_sessions(self, session_ids):
        """Compara padrões entre múltiplas sessões"""
        print(f"🔄 COMPARAÇÃO ENTRE SESSÕES")
        print("="*80)
        
        session_summaries = {}
        
        for session_id in session_ids:
            try:
                data = self.load_session_data(session_id)
                
                # Resumo básico
                summary = {
                    'session_id': session_id,
                    'num_trades': len(data['trades']) if 'trades' in data else 0,
                    'total_volume': data['trades']['volume'].sum() if 'trades' in data else 0,
                    'num_regimes': len(data['regimes']) if 'regimes' in data else 0,
                    'temperatura_media': np.mean([t['temperatura_geral']['temperatura'] for t in data['temperature']]) if 'temperature' in data else 0
                }
                
                session_summaries[session_id] = summary
                
            except Exception as e:
                print(f"❌ Erro ao processar sessão {session_id}: {e}")
        
        # Comparar métricas
        if len(session_summaries) > 1:
            df_comparison = pd.DataFrame(list(session_summaries.values()))
            
            print("\n📊 COMPARAÇÃO DE MÉTRICAS:")
            print(df_comparison.to_string(index=False))
            
            # Encontrar sessão mais ativa
            most_active = df_comparison.loc[df_comparison['total_volume'].idxmax()]
            print(f"\n🏆 SESSÃO MAIS ATIVA: {most_active['session_id']}")
            print(f"   Volume: R$ {most_active['total_volume']:,.0f}")
            print(f"   Trades: {most_active['num_trades']:,}")

def main():
    """Função principal"""
    parser = argparse.ArgumentParser(description='Análise de Padrões - Trading Data')
    parser.add_argument('--session', type=str, help='ID da sessão específica')
    parser.add_argument('--compare', nargs='+', help='IDs das sessões para comparar')
    parser.add_argument('--no-plots', action='store_true', help='Não gerar gráficos')
    parser.add_argument('--data-dir', default='./data', help='Diretório dos dados')
    
    args = parser.parse_args()
    
    analyzer = PatternAnalyzer(args.data_dir)
    
    # Listar sessões disponíveis
    if len(analyzer.sessions) == 0:
        print("❌ Nenhuma sessão encontrada! Execute o profit_dll_monitor.py primeiro.")
        return
    
    print(f"📋 SESSÕES DISPONÍVEIS: {list(analyzer.sessions.keys())}")
    
    if args.compare:
        # Comparar sessões
        analyzer.compare_sessions(args.compare)
    elif args.session:
        # Analisar sessão específica
        analyzer.analyze_session_patterns(args.session, save_plots=not args.no_plots)
    else:
        # Analisar sessão mais recente
        latest_session = max(analyzer.sessions.keys())
        print(f"\n🔍 Analisando sessão mais recente: {latest_session}")
        analyzer.analyze_session_patterns(latest_session, save_plots=not args.no_plots)

if __name__ == "__main__":
    main()