monitor_gui.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Monitor GUI Integration - Integração da GUI com o sistema de monitoramento
Executa o monitor.py com interface gráfica Tkinter
"""

import sys
import threading
import time
from datetime import datetime

# Importar sistema existente
from .monitor import ProfitDLLMonitor
from .trading_gui import TradingGUI

class IntegratedTradingGUI(TradingGUI):
    """GUI integrada com monitor real"""
    
    def __init__(self, monitor_instance, integration_instance):
        super().__init__(monitor_instance=monitor_instance)
        self.integration = integration_instance
        self.monitor_thread = None
        
    def start_monitoring(self):
        """Start integrado com monitor real"""
        print("🚨 INTEGRATED: start_monitoring foi chamado!")
        if not self.running:
            self.running = True
            self.start_button.config(state='disabled')
            self.stop_button.config(state='normal')
            self.status_var.set("🟡 CONECTANDO...")
            
            self.add_log("🔄 INTEGRAÇÃO: Iniciando monitor real...", 'INFO')
            
            # Conectar monitor real em thread separada
            self.monitor_thread = threading.Thread(target=self.integration.run_monitor, daemon=True)
            self.monitor_thread.start()
            
            self.add_log("🚀 INTEGRAÇÃO: Thread do monitor real iniciada", 'SUCCESS')
            
            # Aguardar thread do monitor estabelecer conexão
            self.add_log("⏳ INTEGRAÇÃO: Aguardando estabelecimento da conexão...", 'INFO')
            time.sleep(8)  # Dar tempo para conexão e subscrição
            
            # Iniciar thread de atualização da GUI
            self.update_thread = threading.Thread(target=self.update_loop, daemon=True)
            self.update_thread.start()
            
            self.add_log("✅ INTEGRAÇÃO: Sistema integrado iniciado!", 'SUCCESS')
    
    def stop_monitoring(self):
        """Stop integrado"""
        try:
            if self.integration.monitor and self.integration.monitor.connected:
                self.add_log("🔌 Desconectando do ProfitDLL...", 'INFO')
                self.integration.monitor.disconnect()
            
            self.integration.running = False
            
            if self.running:
                self.running = False
                self.start_button.config(state='normal')
                self.stop_button.config(state='disabled')
                self.status_var.set("🔴 DESCONECTADO")
                
            self.add_log("⏹️ Sistema desconectado", 'WARNING')
            
        except Exception as e:
            self.add_log(f"⚠️ Erro ao desconectar: {e}", 'ERROR')
    
    def update_data(self):
        """Atualização de dados com integração real"""
        try:
            # Verificar se monitor thread foi iniciada
            if not hasattr(self, 'monitor_thread') or not self.monitor_thread:
                self.add_log("⚠️ REAL DATA: Thread do monitor não iniciada ainda", 'WARNING')
                self.update_mock_data()
                return
                
            if not self.integration.monitor:
                self.add_log("⚠️ REAL DATA: Monitor não existe ainda", 'WARNING')
                self.update_mock_data()
                return
            
            # Verificar se thread ainda está ativa    
            if not self.monitor_thread.is_alive():
                self.add_log("⚠️ REAL DATA: Thread do monitor não está ativa", 'WARNING')
                self.update_mock_data()
                return
                
            # Verificar conexão
            if not hasattr(self.integration.monitor, 'connected') or not self.integration.monitor.connected:
                self.add_log(f"⚠️ REAL DATA: Monitor não conectado (connected={getattr(self.integration.monitor, 'connected', 'undefined')})", 'WARNING')
                self.status_var.set("🔴 DESCONECTADO")
                # Usar dados simulados como fallback
                self.update_mock_data()
                return
            
            # Status conectado - atualizar dados reais
            self.status_var.set("🟢 CONECTADO")
            self.add_log("✅ REAL DATA: Atualizando dados reais", 'SUCCESS')
            
            # Usar os dados reais do monitor
            monitor = self.integration.monitor
            
            # Timestamp para as atualizações
            current_time = datetime.now().strftime("%H:%M:%S")
            
            # Análise de temperatura
            if hasattr(monitor, 'calcular_temperatura_atual'):
                temp_analysis = monitor.calcular_temperatura_atual()
                temp = temp_analysis['temperatura_geral']['temperatura']
                temp_emoji = temp_analysis['temperatura_geral']['emoji']
                self.temperatura_var.set(f"{temp:.1f}° {temp_emoji} ({current_time})")
            
            # Análise de regime
            if hasattr(monitor, 'classificar_regime_atual'):
                regime_analysis = monitor.classificar_regime_atual()
                regime = regime_analysis['regime']
                confianca = regime_analysis['confianca']
                self.regime_var.set(f"{regime} ({confianca:.0f}%) - {current_time}")
            
            # Smart Money Analysis
            if hasattr(monitor, 'trade_data') and monitor.trade_data:
                try:
                    from .monitor import calcular_smart_money_consensus
                    smart_consensus = calcular_smart_money_consensus(monitor.trade_data)
                    
                    signal = smart_consensus['smart_money_signal']
                    confidence = smart_consensus['confidence']
                    self.smart_money_var.set(f"{signal} ({current_time})")
                    self.smart_signal_var.set(signal)
                    self.smart_confidence_var.set(f"{confidence:.1f}% - {current_time}")
                    
                    # Líderes com debug expandido
                    if smart_consensus.get('leading_institutions') and len(smart_consensus['leading_institutions']) > 0:
                        leaders = ", ".join([l['nome'] for l in smart_consensus['leading_institutions'][:2]])
                        self.smart_leaders_var.set(f"{leaders} - {current_time}")
                        
                            # Debug detalhado das instituições ativas
                        all_leaders = smart_consensus['leading_institutions'][:3]
                        leader_details = []
                        for leader in all_leaders:
                            volume_k = leader['volume_total'] / 1000
                            leader_details.append(f"{leader['nome']} (R${volume_k:.0f}k {leader['bias']})")
                        
                        self.add_log(f"✅ SMART MONEY: Top 3 institucionais: {', '.join(leader_details)}", 'SUCCESS')
                        self.add_log(f"📊 Total instituições ativas: {smart_consensus.get('total_institutions_active', 0)}", 'INFO')
                        
                        # DEBUG: Comparar com get_all_stats para verificar inconsistência
                        all_stats = monitor.get_all_stats()
                        ubs_stats = all_stats.get(8)  # UBS ID = 8
                        if ubs_stats:
                            ubs_volume = ubs_stats.get('volume_compra_agressor', 0) + ubs_stats.get('volume_venda_agressor', 0)
                            self.add_log(f"🔍 DEBUG UBS: Volume total = R${ubs_volume/1000:.0f}k, Trades = {ubs_stats.get('total_trades', 0)}", 'INFO')
                    else:
                        institutions_count = smart_consensus.get('total_institutions_active', 0)
                        self.smart_leaders_var.set(f"Nenhum líder ativo ({institutions_count} inst.) - {current_time}")
                        self.add_log(f"⚠️ SMART MONEY: {institutions_count} instituições ativas, mas sem líderes", 'WARNING')
                
                except Exception as e:
                    self.add_log(f"⚠️ Erro Smart Money Analysis: {e}", 'WARNING')
                    self.smart_leaders_var.set(f"Erro na análise - {current_time}")
            
            # Trading Engine Stats
            if hasattr(monitor, 'trading_engine'):
                engine = monitor.trading_engine
                contracts_today = engine.stats.get('contracts_today', 0)
                max_contracts = engine.config.get('max_contracts_per_day', 5)
                self.contratos_var.set(f"{contracts_today}/{max_contracts} - {current_time}")
                
                # P&L
                summary = engine.get_portfolio_summary()
                current_capital = summary.get('current_capital', engine.initial_capital)
                pnl = current_capital - engine.initial_capital
                pnl_pct = (pnl / engine.initial_capital) * 100
                self.pnl_var.set(f"R$ {pnl:+,.0f} ({pnl_pct:+.1f}%) - {current_time}")
            
            # Análise de Fluxo (Domínio)
            if hasattr(monitor, 'get_fluxo_analysis'):
                fluxo = monitor.get_fluxo_analysis()
                dominio = fluxo.get('dominio', 'equilibrado')
                
                if dominio == 'institucional':
                    pct = fluxo.get('percentual_institucional', 0)
                    self.dominio_var.set(f"🏦 Institucional ({pct:.1f}%) - {current_time}")
                elif dominio == 'varejo':
                    pct = fluxo.get('percentual_varejo', 0)
                    self.dominio_var.set(f"🏪 Varejo ({pct:.1f}%) - {current_time}")
                else:
                    self.dominio_var.set(f"⚖️ Equilibrado - {current_time}")
            
        except Exception as e:
            self.add_log(f"⚠️ Erro atualização dados reais: {e}", 'WARNING')
            # Fallback para dados simulados
            self.update_mock_data()

class MonitorGUIIntegration:
    """Classe que integra o Monitor com a GUI"""
    
    def __init__(self):
        """Inicializa a integração"""
        self.monitor = None
        self.gui = None
        self.monitor_thread = None
        self.running = False
        
    def start_with_gui(self):
        """Inicia o sistema com interface gráfica"""
        print("🚀 Iniciando Trading Monitor com Interface Gráfica...")
        
        try:
            # Criar instância do monitor (sem iniciar ainda)
            self.monitor = ProfitDLLMonitor("./lib/ProfitDLL.dll")
            
            # Criar GUI com integração customizada
            self.gui = IntegratedTradingGUI(self.monitor, self)
            
            # Executar GUI
            print("🎨 Interface gráfica iniciada!")
            self.gui.run()
            
        except KeyboardInterrupt:
            print("\n⚠️ Interrompido pelo usuário")
        except Exception as e:
            print(f"❌ Erro: {e}")
        finally:
            self.cleanup()
    
    
    def run_monitor(self):
        """Executa o monitor em thread separada"""
        try:
            self.running = True
            self.gui.add_log("🚀 MONITOR: Thread iniciada", 'INFO')
            self.gui.add_log("🔌 MONITOR: Carregando credenciais...", 'INFO')
            
            # Carregar credenciais
            from .monitor import load_credentials
            credentials = load_credentials("./config/credencial.txt")
            
            if not credentials:
                self.gui.add_log("❌ Falha ao carregar credenciais!", 'ERROR')
                self.gui.add_log("💡 Verifique o arquivo credencial.txt", 'INFO')
                return
                
            self.gui.add_log("🔌 MONITOR: Tentando conectar ao ProfitDLL...", 'INFO')
            
            # Conectar com credenciais
            if self.monitor.connect(
                credentials['ACTIVATION_KEY'],
                credentials['USERNAME'], 
                credentials['PASSWORD']
            ):
                self.gui.add_log("✅ MONITOR: Conectado ao ProfitDLL com sucesso!", 'SUCCESS')
                
                # Aguardar estabilização da conexão
                time.sleep(2)
                self.gui.add_log(f"🔗 MONITOR: Status conexão: {self.monitor.connected}", 'INFO')
                
                # Inscrever no WINV25
                self.gui.add_log("📡 MONITOR: Inscrevendo no WINV25...", 'INFO')
                if self.monitor.subscribe_ticker("WINV25", "F"):
                    self.gui.add_log("✅ MONITOR: Inscrito no WINV25!", 'SUCCESS')
                else:
                    self.gui.add_log("⚠️ MONITOR: Falha ao inscrever no WINV25", 'WARNING')
                
                # Aguardar dados iniciais
                time.sleep(3)
                self.gui.add_log("📊 MONITOR: Aguardando primeiros dados...", 'INFO')
                
                # Loop principal (completo com coleta ML)
                update_count = 0
                while self.running and self.monitor.connected:
                    time.sleep(5)  # Check mais frequente
                    update_count += 1
                    
                    # Análises completas e coleta de dados a cada 15 segundos (3 updates)
                    if update_count % 3 == 0:
                        try:
                            # Executar análises completas como no monitor.py
                            regime_analysis = self.monitor.classificar_regime_atual()
                            temp_analysis = self.monitor.calcular_temperatura_atual()
                            fluxo_analysis = self.monitor.get_fluxo_analysis()
                            all_stats = self.monitor.get_all_stats()
                            
                            # COLETAR SNAPSHOT COMPLETO DO MERCADO para ML
                            if hasattr(self.monitor, 'data_collector'):
                                self.monitor.data_collector.collect_market_snapshot(
                                    all_stats, fluxo_analysis, temp_analysis, regime_analysis
                                )
                                self.gui.add_log("📊 SNAPSHOT: Dados ML coletados", 'INFO')
                            
                            total_trades = sum(s.get('total_trades', 0) for s in all_stats.values())
                            self.gui.add_log(f"📊 MONITOR: {total_trades} trades coletados, conectado: {self.monitor.connected}", 'INFO')
                            
                        except Exception as e:
                            self.gui.add_log(f"⚠️ MONITOR: Erro ao obter stats/snapshot: {e}", 'WARNING')
                
            else:
                self.gui.add_log("❌ MONITOR: Falha na conexão com ProfitDLL", 'ERROR')
                self.gui.add_log("💡 Verifique credenciais em credencial.txt", 'INFO')
                
        except Exception as e:
            self.gui.add_log(f"💥 MONITOR: Erro no monitor: {e}", 'ERROR')
        finally:
            if self.monitor and hasattr(self.monitor, 'connected') and self.monitor.connected:
                self.monitor.disconnect()
                self.gui.add_log("🔌 MONITOR: Desconectado do ProfitDLL", 'INFO')
    
    def cleanup(self):
        """Limpeza final"""
        self.running = False
        if self.monitor and self.monitor.connected:
            self.monitor.disconnect()
        print("🧹 Limpeza concluída")


def main():
    """Função principal"""
    print("=" * 80)
    print("🔥 TRADING MONITOR - INTERFACE GRÁFICA")
    print("=" * 80)
    print("🎨 Iniciando sistema com GUI...")
    print("💡 Use os controles da interface para conectar")
    print("=" * 80)
    
    # Criar e iniciar integração
    integration = MonitorGUIIntegration()
    integration.start_with_gui()


if __name__ == "__main__":
    main()