trading_gui.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Trading Monitor GUI - Interface gráfica Tkinter
Sistema completo de monitoramento de trading em tempo real
"""

import tkinter as tk
from tkinter import ttk, messagebox
from datetime import datetime
import threading
import time
import json

class TradingGUI:
    """Interface gráfica principal para o Trading Monitor"""
    
    def __init__(self, monitor_instance=None):
        """
        Inicializa a interface gráfica
        
        Args:
            monitor_instance: Instância do Monitor (opcional - para testes)
        """
        self.monitor = monitor_instance
        self.running = False
        self.update_thread = None
        
        # Configurar janela principal
        self.root = tk.Tk()
        self.root.title("🔥 Trading Monitor - WINV25")
        self.root.geometry("1200x800")
        self.root.configure(bg='#1a1a1a')  # Tema escuro
        
        # Variáveis para dados em tempo real
        self.temperatura_var = tk.StringVar(value="--°")
        self.regime_var = tk.StringVar(value="Conectando...")
        self.smart_money_var = tk.StringVar(value="AGUARDANDO")
        self.contratos_var = tk.StringVar(value="0/5")
        self.dominio_var = tk.StringVar(value="--")
        self.pnl_var = tk.StringVar(value="R$ 0,00")
        self.status_var = tk.StringVar(value="🔴 DESCONECTADO")
        
        # Variáveis para Smart Money
        self.smart_signal_var = tk.StringVar(value="NEUTRO")
        self.smart_confidence_var = tk.StringVar(value="0%")
        self.smart_leaders_var = tk.StringVar(value="Carregando...")
        
        # Lista de decisões de trading
        self.trading_decisions = []
        
        # Criar interface
        self.create_interface()
        
        # Configurar protocolo de fechamento
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        
    def create_interface(self):
        """Cria todos os elementos da interface"""
        
        # ==================== HEADER ====================
        header_frame = tk.Frame(self.root, bg='#2d2d2d', height=60)
        header_frame.pack(fill=tk.X, padx=5, pady=(5,0))
        header_frame.pack_propagate(False)
        
        # Título e status
        title_label = tk.Label(
            header_frame, 
            text="🔥 TRADING MONITOR - WINV25", 
            font=('Arial', 16, 'bold'),
            fg='#ffffff', bg='#2d2d2d'
        )
        title_label.pack(side=tk.LEFT, padx=20, pady=15)
        
        status_label = tk.Label(
            header_frame,
            textvariable=self.status_var,
            font=('Arial', 12, 'bold'),
            fg='#ff4444', bg='#2d2d2d'
        )
        status_label.pack(side=tk.RIGHT, padx=20, pady=15)
        
        # ==================== MÉTRICAS PRINCIPAIS ====================
        metrics_frame = tk.Frame(self.root, bg='#1a1a1a')
        metrics_frame.pack(fill=tk.X, padx=5, pady=5)
        
        # Criar 6 caixas de métrica
        self.create_metric_box(metrics_frame, "🌡️ TEMPERATURA", self.temperatura_var, "#ff6b35", 0, 0)
        self.create_metric_box(metrics_frame, "📊 REGIME", self.regime_var, "#4ecdc4", 0, 1)
        self.create_metric_box(metrics_frame, "🧠 SMART MONEY", self.smart_money_var, "#45b7d1", 0, 2)
        
        self.create_metric_box(metrics_frame, "💰 CONTRATOS", self.contratos_var, "#96c93f", 1, 0)
        self.create_metric_box(metrics_frame, "🏦 DOMÍNIO", self.dominio_var, "#f7b731", 1, 1)
        self.create_metric_box(metrics_frame, "💵 P&L", self.pnl_var, "#5f27cd", 1, 2)
        
        # ==================== SMART MONEY DETALHADO ====================
        smart_frame = tk.LabelFrame(
            self.root, 
            text="🧠 SMART MONEY CONSENSUS", 
            font=('Arial', 12, 'bold'),
            fg='#ffffff', bg='#2d2d2d'
        )
        smart_frame.pack(fill=tk.X, padx=5, pady=5)
        
        # Smart Money row 1
        smart_row1 = tk.Frame(smart_frame, bg='#2d2d2d')
        smart_row1.pack(fill=tk.X, padx=10, pady=5)
        
        tk.Label(smart_row1, text="Sinal:", font=('Arial', 10), fg='#cccccc', bg='#2d2d2d').pack(side=tk.LEFT)
        signal_label = tk.Label(smart_row1, textvariable=self.smart_signal_var, font=('Arial', 10, 'bold'), fg='#4ecdc4', bg='#2d2d2d')
        signal_label.pack(side=tk.LEFT, padx=(5,20))
        
        tk.Label(smart_row1, text="Confiança:", font=('Arial', 10), fg='#cccccc', bg='#2d2d2d').pack(side=tk.LEFT)
        confidence_label = tk.Label(smart_row1, textvariable=self.smart_confidence_var, font=('Arial', 10, 'bold'), fg='#96c93f', bg='#2d2d2d')
        confidence_label.pack(side=tk.LEFT, padx=(5,0))
        
        # Smart Money row 2 - Líderes
        smart_row2 = tk.Frame(smart_frame, bg='#2d2d2d')
        smart_row2.pack(fill=tk.X, padx=10, pady=(0,10))
        
        tk.Label(smart_row2, text="Líderes:", font=('Arial', 10), fg='#cccccc', bg='#2d2d2d').pack(side=tk.LEFT)
        leaders_label = tk.Label(smart_row2, textvariable=self.smart_leaders_var, font=('Arial', 10), fg='#f7b731', bg='#2d2d2d')
        leaders_label.pack(side=tk.LEFT, padx=(5,0))
        
        # ==================== PAINEL CENTRAL ====================
        central_frame = tk.Frame(self.root, bg='#1a1a1a')
        central_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # ==================== DECISÕES DE TRADING ====================
        left_frame = tk.Frame(central_frame, bg='#1a1a1a')
        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0,2))
        
        decisions_label_frame = tk.LabelFrame(
            left_frame, 
            text="🤖 DECISÕES DE TRADING", 
            font=('Arial', 12, 'bold'),
            fg='#ffffff', bg='#2d2d2d'
        )
        decisions_label_frame.pack(fill=tk.BOTH, expand=True)
        
        # Lista de decisões com scrollbar
        decisions_frame = tk.Frame(decisions_label_frame, bg='#2d2d2d')
        decisions_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        self.decisions_listbox = tk.Listbox(
            decisions_frame,
            font=('Consolas', 9),
            bg='#1a1a1a',
            fg='#ffffff',
            selectbackground='#4ecdc4',
            selectforeground='#000000',
            height=15
        )
        
        decisions_scrollbar = tk.Scrollbar(decisions_frame, orient="vertical")
        self.decisions_listbox.config(yscrollcommand=decisions_scrollbar.set)
        decisions_scrollbar.config(command=self.decisions_listbox.yview)
        
        self.decisions_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        decisions_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # ==================== PAINEL DE CONTROLE ====================
        right_frame = tk.Frame(central_frame, bg='#1a1a1a', width=300)
        right_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(2,0))
        right_frame.pack_propagate(False)
        
        control_frame = tk.LabelFrame(
            right_frame, 
            text="🎛️ CONTROLES", 
            font=('Arial', 12, 'bold'),
            fg='#ffffff', bg='#2d2d2d'
        )
        control_frame.pack(fill=tk.X, pady=(0,5))
        
        # Botões de controle
        self.start_button = tk.Button(
            control_frame,
            text="▶️ INICIAR MONITOR",
            command=self.start_monitoring,
            bg='#27ae60',
            fg='white',
            font=('Arial', 10, 'bold'),
            height=2
        )
        self.start_button.pack(fill=tk.X, padx=10, pady=5)
        
        self.stop_button = tk.Button(
            control_frame,
            text="⏸️ PARAR MONITOR", 
            command=self.stop_monitoring,
            bg='#e74c3c',
            fg='white',
            font=('Arial', 10, 'bold'),
            height=2,
            state='disabled'
        )
        self.stop_button.pack(fill=tk.X, padx=10, pady=5)
        
        # ==================== LOG DE STATUS ====================
        log_frame = tk.LabelFrame(
            right_frame, 
            text="📋 LOG", 
            font=('Arial', 12, 'bold'),
            fg='#ffffff', bg='#2d2d2d'
        )
        log_frame.pack(fill=tk.BOTH, expand=True)
        
        self.log_text = tk.Text(
            log_frame,
            font=('Consolas', 8),
            bg='#1a1a1a',
            fg='#cccccc',
            height=10,
            wrap=tk.WORD
        )
        
        log_scrollbar = tk.Scrollbar(log_frame, orient="vertical")
        self.log_text.config(yscrollcommand=log_scrollbar.set)
        log_scrollbar.config(command=self.log_text.yview)
        
        self.log_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
        log_scrollbar.pack(side=tk.RIGHT, fill=tk.Y, pady=5)
        
        # Log inicial
        self.add_log("🚀 Interface gráfica iniciada")
        self.add_log("ℹ️ Clique em 'INICIAR MONITOR' para conectar")
        
    def create_metric_box(self, parent, title, variable, color, row, col):
        """Cria uma caixa de métrica"""
        frame = tk.Frame(parent, bg='#2d2d2d', relief='raised', bd=1)
        frame.grid(row=row, column=col, padx=5, pady=5, sticky='nsew')
        
        # Configurar grid
        parent.grid_rowconfigure(row, weight=1)
        parent.grid_columnconfigure(col, weight=1)
        
        # Título
        title_label = tk.Label(
            frame,
            text=title,
            font=('Arial', 10, 'bold'),
            fg='#cccccc',
            bg='#2d2d2d'
        )
        title_label.pack(pady=(10, 5))
        
        # Valor
        value_label = tk.Label(
            frame,
            textvariable=variable,
            font=('Arial', 14, 'bold'),
            fg=color,
            bg='#2d2d2d'
        )
        value_label.pack(pady=(0, 10))
        
    def add_log(self, message, level='INFO'):
        """Adiciona mensagem ao log (thread-safe)"""
        def _add_log_safe():
            timestamp = datetime.now().strftime('%H:%M:%S')
            log_colors = {
                'INFO': '#cccccc',
                'SUCCESS': '#27ae60', 
                'WARNING': '#f39c12',
                'ERROR': '#e74c3c'
            }
            
            # Adicionar ao texto
            self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
            self.log_text.see(tk.END)
            
            # Limitar linhas do log (últimas 100)
            lines = self.log_text.get("1.0", tk.END).count('\n')
            if lines > 100:
                self.log_text.delete("1.0", "2.0")
        
        # Executar na thread principal se necessário
        if threading.current_thread() != threading.main_thread():
            self.root.after(0, _add_log_safe)
        else:
            _add_log_safe()
    
    def add_trading_decision(self, decision_text):
        """Adiciona uma decisão de trading à lista (thread-safe)"""
        def _add_decision_safe():
            timestamp = datetime.now().strftime('%H:%M:%S')
            full_text = f"[{timestamp}] {decision_text}"
            
            self.decisions_listbox.insert(0, full_text)  # Inserir no topo
            
            # Limitar a 50 decisões
            if self.decisions_listbox.size() > 50:
                self.decisions_listbox.delete(tk.END)
                
            # Auto-scroll para o topo
            self.decisions_listbox.see(0)
        
        # Executar na thread principal se necessário
        if threading.current_thread() != threading.main_thread():
            self.root.after(0, _add_decision_safe)
        else:
            _add_decision_safe()
    
    def start_monitoring(self):
        """Inicia o monitoramento"""
        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("🔄 Iniciando sistema de monitoramento...", 'INFO')
            
            # Iniciar thread de atualização
            self.update_thread = threading.Thread(target=self.update_loop, daemon=True)
            self.update_thread.start()
    
    def stop_monitoring(self):
        """Para o monitoramento"""
        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 de monitoramento parado", 'WARNING')
    
    def update_loop(self):
        """Loop principal de atualização (roda em thread separada)"""
        self.add_log("🚀 Thread de atualização iniciada", 'SUCCESS')
        
        # Simular conexão
        time.sleep(2)
        self.root.after(0, lambda: self.status_var.set("🟢 CONECTADO"))
        self.root.after(0, lambda: self.add_log("✅ Conectado ao sistema ProfitDLL", 'SUCCESS'))
        
        update_count = 0
        
        while self.running:
            try:
                # Agendar atualização na thread principal do Tkinter
                self.root.after(0, self.update_data)
                
                update_count += 1
                if update_count % 4 == 0:  # A cada 1 minuto (15s * 4)
                    self.root.after(0, lambda c=update_count: self.add_log(f"🔄 Dados atualizados - Ciclo {c//4}"))
                
                time.sleep(15)  # Atualizar a cada 15 segundos
                
            except Exception as e:
                self.root.after(0, lambda e=e: self.add_log(f"❌ Erro na atualização: {e}", 'ERROR'))
                time.sleep(5)
    
    def update_data(self):
        """Atualiza os dados da interface"""
        try:
            if self.monitor:
                # Dados reais do monitor
                self.update_real_data()
            else:
                # Dados simulados para demonstração
                self.update_mock_data()
                
        except Exception as e:
            self.add_log(f"⚠️ Erro ao atualizar dados: {e}", 'ERROR')
    
    def update_real_data(self):
        """Atualiza com dados reais do monitor"""
        try:
            # Análise de temperatura
            temp_analysis = self.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}")
            
            # Análise de regime
            regime_analysis = self.monitor.classificar_regime_atual()
            regime = regime_analysis['regime']
            confianca = regime_analysis['confianca']
            self.regime_var.set(f"{regime} ({confianca:.0f}%)")
            
            # Smart Money
            smart_consensus = self.monitor.calcular_smart_money_consensus(self.monitor.trade_data)
            signal = smart_consensus['smart_money_signal']
            confidence = smart_consensus['confidence']
            self.smart_money_var.set(f"{signal}")
            self.smart_signal_var.set(signal)
            self.smart_confidence_var.set(f"{confidence:.1f}%")
            
            # Líderes Smart Money
            if smart_consensus['leading_institutions']:
                leaders = ", ".join([l['nome'] for l in smart_consensus['leading_institutions'][:3]])
                self.smart_leaders_var.set(leaders)
            
            # Trading Engine
            if hasattr(self.monitor, 'trading_engine'):
                engine = self.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}")
                
                summary = engine.get_portfolio_summary()
                pnl = summary.get('total_return', 0)
                self.pnl_var.set(f"R$ {pnl:+,.2f}")
            
            # Domínio
            fluxo = self.monitor.get_fluxo_analysis()
            dominio = fluxo.get('dominio', 'equilibrado')
            pct = fluxo.get('percentual_institucional', 0) if dominio == 'institucional' else fluxo.get('percentual_varejo', 0)
            self.dominio_var.set(f"{dominio.title()} ({pct:.1f}%)")
            
        except Exception as e:
            self.add_log(f"🔧 Erro dados reais: {e}", 'WARNING')
            self.update_mock_data()
    
    def update_mock_data(self):
        """Atualiza com dados simulados (para demonstração)"""
        import random
        
        print("🔄 Executando update_mock_data...")  # Debug
        
        # Temperatura simulada
        temp = random.uniform(8, 25)
        temp_emoji = "🔥" if temp > 20 else "🌡️" if temp > 10 else "❄️"
        self.temperatura_var.set(f"{temp:.1f}° {temp_emoji}")
        
        # Regime simulado
        regimes = ["Trending Bull", "Trending Bear", "Sideways", "Alta Volatilidade"]
        regime = random.choice(regimes)
        conf = random.randint(60, 95)
        self.regime_var.set(f"{regime} ({conf}%)")
        
        # Smart Money simulado
        signals = ["COMPRA", "VENDA", "NEUTRO", "COMPRA_FRACO", "VENDA_FRACO"]
        signal = random.choice(signals)
        confidence = random.randint(50, 90)
        self.smart_money_var.set(signal)
        self.smart_signal_var.set(signal)
        self.smart_confidence_var.set(f"{confidence}%")
        
        # Líderes simulados
        leaders = ["UBS, Goldman", "StoneX, JPMorgan", "Merrill, Morgan", "XP, BTG"]
        self.smart_leaders_var.set(random.choice(leaders))
        
        # Contratos simulados
        contracts = random.randint(0, 5)
        self.contratos_var.set(f"{contracts}/5")
        
        # P&L simulado
        pnl = random.uniform(-5000, 8000)
        self.pnl_var.set(f"R$ {pnl:+,.2f}")
        
        # Domínio simulado
        dominios = ["🏦 Institucional (62%)", "🏪 Varejo (48%)", "⚖️ Equilibrado (51%)"]
        self.dominio_var.set(random.choice(dominios))
        
        # Adicionar decisão simulada ocasionalmente
        if random.random() < 0.2:  # 20% chance
            decisions = [
                "🟢 BUY 2 WINV25 @ 120.580 - Smart Money 78% COMPRA",
                "🔴 SELL 1 WINV25 @ 119.920 - Stop Loss atingido",
                "🟡 AGUARDAR - Confiança regime baixa (45%)",
                "🟢 BUY 1 WINV25 @ 121.230 - Trending Bull confirmado",
                "🔴 SELL 3 WINV25 @ 120.140 - Take Profit atingido"
            ]
            self.add_trading_decision(random.choice(decisions))
            
        print(f"✅ Mock data atualizado: Temp={self.temperatura_var.get()}, Regime={self.regime_var.get()}")  # Debug
    
    def on_closing(self):
        """Chamado quando janela é fechada"""
        if self.running:
            if messagebox.askokcancel("Sair", "O monitoramento ainda está ativo. Deseja parar e sair?"):
                self.running = False
                time.sleep(1)  # Aguardar thread finalizar
                self.root.destroy()
        else:
            self.root.destroy()
    
    def run(self):
        """Executa a interface gráfica"""
        self.add_log("🎨 Interface gráfica pronta!")
        self.add_log("💡 Dica: Inicie o monitor para ver dados em tempo real")
        self.root.mainloop()


def main():
    """Função principal para testar a GUI"""
    print("🎨 Iniciando Trading GUI...")
    
    # Para testar sem monitor real, passar None
    # Para usar monitor real, importar e passar instância
    gui = TradingGUI(monitor_instance=None)
    gui.run()


if __name__ == "__main__":
    main()