trading_platform.py

import customtkinter as ctk
from tkinter import messagebox, ttk, simpledialog
import threading
import queue
from datetime import datetime, timedelta
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import mplfinance as mpf
import json
import os

# Import our trading modules
from alpaca_trader import AlpacaTrader
from strategy_engine import StrategyEngine
from data_manager import DataManager

# Import new modules
import config
from security import CredentialManager, InputValidator, ValidationError, RateLimitError
from logger import system_logger, trading_logger
from database import DatabaseManager
from risk_manager import RiskManager, RiskLimits, RiskException
from notification_system import notification_system, NotificationLevel
from market_hours import market_hours
from transaction_viewer import open_transaction_viewer
from chart_components import PortfolioChart, PriceChart, PerformanceMetrics
from ui_utils import ToolTip, StatusBar

# Ensure required directories exist
config.ensure_directories()

ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")


class TradingPlatform(ctk.CTk):
    """
    Complete AI Trading Platform with GUI
    Features: Manual trading, Auto trading, Analytics, Portfolio management
    """
    
    def __init__(self):
        super().__init__()
        
        # Window setup
        self.title(f"{config.APP_NAME} v{config.APP_VERSION}")
        self.geometry(f"{config.WINDOW_WIDTH}x{config.WINDOW_HEIGHT}")
        
        # Initialize components
        self.trader = None
        self.strategy_engine = None
        self.data_manager = DataManager()
        self.credential_manager = CredentialManager()
        self.database = DatabaseManager()
        self.risk_manager = RiskManager()
        self.auto_trading_active = False
        self.update_queue = queue.Queue()
        
        # Auto-refresh control
        self.auto_refresh_active = config.AUTO_REFRESH_ENABLED
        self.auto_refresh_thread = None
        self.auto_scan_thread = None
        self.dashboard_update_thread = None
        self._stop_auto_threads = threading.Event()
        
        # Subscribe to notifications
        notification_system.subscribe(self.handle_notification, 'ALL')
        
        # Log startup
        system_logger.info(f"{config.APP_NAME} v{config.APP_VERSION} starting...")
        
        # Create UI
        self.create_widgets()
        
        # Check for saved credentials
        self.check_saved_credentials()
        
        # NOTE: Auto-refresh will start after connecting to Alpaca
        # Starting threads before connection causes freeze
        # See connect_to_alpaca() method
        
        # Handle window close
        self.protocol("WM_DELETE_WINDOW", self.on_closing)
    
    def create_widgets(self):
        """Create all UI widgets"""
        
        # Main container
        self.grid_columnconfigure(1, weight=1)
        self.grid_rowconfigure(0, weight=1)
        
        # Sidebar
        self.create_sidebar()
        
        # Main content area with tabs
        self.tabview = ctk.CTkTabview(self, width=1100)
        self.tabview.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
        
        # Create tabs
        self.tabview.add("Dashboard")
        self.tabview.add("Trading")
        self.tabview.add("Portfolio")
        self.tabview.add("Auto Trading")
        self.tabview.add("Analytics")
        self.tabview.add("Settings")
        
        # Setup each tab
        self.setup_dashboard_tab()
        self.setup_trading_tab()
        self.setup_portfolio_tab()
        self.setup_auto_trading_tab()
        self.setup_analytics_tab()
        self.setup_settings_tab()
        
        # Status bar at bottom (NEW)
        self.status_bar = StatusBar(self)
        self.status_bar.grid(row=2, column=0, columnspan=2, sticky="ew", padx=0, pady=0)
        
        # Default to Dashboard tab
        self.tabview.set("Dashboard")
        
        # Start processing updates
        self.after(100, self.process_updates)
        
        # Keyboard shortcuts (after all widgets created)
        self.bind("<Control-r>", lambda e: self.refresh_data())
        self.bind("<Control-h>", lambda e: self.open_transaction_history())
        self.bind("<Control-q>", lambda e: self.on_closing())
        self.bind("<F1>", lambda e: self.show_help())
    
    def create_sidebar(self):
        """Create sidebar with account info and quick actions"""
        self.sidebar_frame = ctk.CTkFrame(self, width=280, corner_radius=0)
        self.sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew")
        self.sidebar_frame.grid_rowconfigure(10, weight=1)
        
        # Logo/Title
        self.logo_label = ctk.CTkLabel(
            self.sidebar_frame,
            text="🤖 AI Trading",
            font=ctk.CTkFont(size=24, weight="bold")
        )
        self.logo_label.grid(row=0, column=0, padx=20, pady=(20, 10))
        
        # Connection status
        self.status_frame = ctk.CTkFrame(self.sidebar_frame)
        self.status_frame.grid(row=1, column=0, padx=20, pady=10, sticky="ew")
        
        self.status_label = ctk.CTkLabel(
            self.status_frame,
            text="● Disconnected",
            font=ctk.CTkFont(size=12),
            text_color="red"
        )
        self.status_label.pack(pady=5)
        
        # Account info
        self.account_frame = ctk.CTkFrame(self.sidebar_frame)
        self.account_frame.grid(row=2, column=0, padx=20, pady=10, sticky="ew")
        
        ctk.CTkLabel(
            self.account_frame,
            text="Account Balance",
            font=ctk.CTkFont(size=12, weight="bold")
        ).pack(pady=(10, 0))
        
        self.balance_label = ctk.CTkLabel(
            self.account_frame,
            text="$0.00",
            font=ctk.CTkFont(size=20, weight="bold")
        )
        self.balance_label.pack(pady=5)
        
        self.buying_power_label = ctk.CTkLabel(
            self.account_frame,
            text="Buying Power: $0.00",
            font=ctk.CTkFont(size=11)
        )
        self.buying_power_label.pack(pady=(0, 10))
        
        # Quick stats
        self.stats_frame = ctk.CTkFrame(self.sidebar_frame)
        self.stats_frame.grid(row=3, column=0, padx=20, pady=10, sticky="ew")
        
        self.positions_label = ctk.CTkLabel(
            self.stats_frame,
            text="Positions: 0",
            font=ctk.CTkFont(size=11)
        )
        self.positions_label.pack(pady=5)
        
        self.day_pl_label = ctk.CTkLabel(
            self.stats_frame,
            text="Day P&L: $0.00",
            font=ctk.CTkFont(size=11)
        )
        self.day_pl_label.pack(pady=5)
        
        # Market status
        self.market_status_label = ctk.CTkLabel(
            self.stats_frame,
            text="Market: UNKNOWN",
            font=ctk.CTkFont(size=11)
        )
        self.market_status_label.pack(pady=5)
        
        # Quick actions
        ctk.CTkLabel(
            self.sidebar_frame,
            text="Quick Actions",
            font=ctk.CTkFont(size=14, weight="bold")
        ).grid(row=4, column=0, padx=20, pady=(20, 10))
        
        self.refresh_btn = ctk.CTkButton(
            self.sidebar_frame,
            text="🔄 Refresh Data",
            command=self.refresh_data
        )
        self.refresh_btn.grid(row=5, column=0, padx=20, pady=5)
        ToolTip(self.refresh_btn, "Manually refresh account data and positions")
        
        self.scan_btn = ctk.CTkButton(
            self.sidebar_frame,
            text="🔍 Scan Markets",
            command=self.scan_markets
        )
        self.scan_btn.grid(row=6, column=0, padx=20, pady=5)
        ToolTip(self.scan_btn, "Scan all watchlist stocks for trading opportunities")

        self.orders_queue_btn = ctk.CTkButton(
            self.sidebar_frame,
            text="📋 Orders & Queue",
            command=self.show_orders_queue
        )
        self.orders_queue_btn.grid(row=7, column=0, padx=20, pady=5)
        ToolTip(self.orders_queue_btn, "View pending orders and queued trades")
        
        self.emergency_stop_btn = ctk.CTkButton(
            self.sidebar_frame,
            text="🛑 Emergency Stop",
            fg_color="red",
            hover_color="darkred",
            command=self.emergency_stop
        )
        self.emergency_stop_btn.grid(row=8, column=0, padx=20, pady=10)
        ToolTip(self.emergency_stop_btn, "Close all positions immediately and halt trading")
        
        # Appearance mode
        ctk.CTkLabel(
            self.sidebar_frame,
            text="Appearance",
            font=ctk.CTkFont(size=12)
        ).grid(row=9, column=0, padx=20, pady=(20, 5))
        
        self.appearance_mode = ctk.CTkOptionMenu(
            self.sidebar_frame,
            values=["Dark", "Light", "System"],
            command=self.change_appearance_mode
        )
        self.appearance_mode.grid(row=10, column=0, padx=20, pady=(0, 20))
        self.appearance_mode.set("Dark")
    
    def setup_dashboard_tab(self):
        """Setup main dashboard"""
        tab = self.tabview.tab("Dashboard")
        
        # Create grid layout
        tab.grid_columnconfigure((0, 1), weight=1)
        tab.grid_rowconfigure((0, 1), weight=1)
        
        # Market overview
        market_frame = ctk.CTkFrame(tab)
        market_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            market_frame,
            text="📊 Market Overview",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        self.market_status_text = ctk.CTkTextbox(market_frame, height=200)
        self.market_status_text.pack(padx=10, pady=10, fill="both", expand=True)
        
        # Recent signals
        signals_frame = ctk.CTkFrame(tab)
        signals_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            signals_frame,
            text="🎯 Recent Signals",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        self.signals_text = ctk.CTkTextbox(signals_frame, height=200)
        self.signals_text.pack(padx=10, pady=10, fill="both", expand=True)
        
        # Portfolio summary
        portfolio_frame = ctk.CTkFrame(tab)
        portfolio_frame.grid(row=1, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            portfolio_frame,
            text="💼 Portfolio Summary",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        self.portfolio_text = ctk.CTkTextbox(portfolio_frame, height=200)
        self.portfolio_text.pack(padx=10, pady=10, fill="both", expand=True)
        
        # Recent activity
        activity_frame = ctk.CTkFrame(tab)
        activity_frame.grid(row=1, column=1, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            activity_frame,
            text="📝 Recent Activity",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        self.activity_text = ctk.CTkTextbox(activity_frame, height=200)
        self.activity_text.pack(padx=10, pady=10, fill="both", expand=True)
    
    def setup_trading_tab(self):
        """Setup manual trading interface"""
        tab = self.tabview.tab("Trading")
        
        # Split into two columns
        tab.grid_columnconfigure(0, weight=1)
        tab.grid_columnconfigure(1, weight=2)
        tab.grid_rowconfigure(0, weight=1)
        
        # Order entry panel
        order_frame = ctk.CTkFrame(tab)
        order_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            order_frame,
            text="📈 Place Order",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        # Symbol entry
        ctk.CTkLabel(order_frame, text="Symbol:").pack(pady=(10, 0))
        self.symbol_entry = ctk.CTkEntry(order_frame, placeholder_text="NVDA")
        self.symbol_entry.pack(pady=5)
        
        # Quantity
        ctk.CTkLabel(order_frame, text="Quantity:").pack(pady=(10, 0))
        self.quantity_entry = ctk.CTkEntry(order_frame, placeholder_text="10")
        self.quantity_entry.pack(pady=5)
        
        # Order type
        ctk.CTkLabel(order_frame, text="Order Type:").pack(pady=(10, 0))
        self.order_type = ctk.CTkOptionMenu(
            order_frame,
            values=["Market", "Limit", "Stop", "Stop Limit"]
        )
        self.order_type.pack(pady=5)
        
        # Price (for limit orders)
        ctk.CTkLabel(order_frame, text="Limit Price:").pack(pady=(10, 0))
        self.price_entry = ctk.CTkEntry(order_frame, placeholder_text="Optional")
        self.price_entry.pack(pady=5)
        
        # Action buttons
        button_frame = ctk.CTkFrame(order_frame, fg_color="transparent")
        button_frame.pack(pady=20)
        
        self.buy_btn = ctk.CTkButton(
            button_frame,
            text="📈 BUY",
            fg_color="green",
            hover_color="darkgreen",
            command=lambda: self.place_order("buy"),
            width=120
        )
        self.buy_btn.pack(side="left", padx=5)
        
        self.sell_btn = ctk.CTkButton(
            button_frame,
            text="📉 SELL",
            fg_color="red",
            hover_color="darkred",
            command=lambda: self.place_order("sell"),
            width=120
        )
        self.sell_btn.pack(side="left", padx=5)
        
        # Quote button
        self.quote_btn = ctk.CTkButton(
            order_frame,
            text="💰 Get Quote",
            command=self.get_quote
        )
        self.quote_btn.pack(pady=10)
        
        self.quote_label = ctk.CTkLabel(
            order_frame,
            text="",
            font=ctk.CTkFont(size=12)
        )
        self.quote_label.pack(pady=5)
        
        # Chart panel
        chart_frame = ctk.CTkFrame(tab)
        chart_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            chart_frame,
            text="📊 Price Chart",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        # Chart controls
        chart_controls = ctk.CTkFrame(chart_frame, fg_color="transparent")
        chart_controls.pack(pady=5)
        
        self.chart_symbol = ctk.CTkEntry(
            chart_controls,
            placeholder_text="Symbol",
            width=100
        )
        self.chart_symbol.pack(side="left", padx=5)
        
        self.chart_period = ctk.CTkOptionMenu(
            chart_controls,
            values=["1D", "5D", "1M", "3M", "6M", "1Y"],
            width=80
        )
        self.chart_period.pack(side="left", padx=5)
        self.chart_period.set("1M")
        
        ctk.CTkButton(
            chart_controls,
            text="Load Chart",
            command=self.load_chart,
            width=100
        ).pack(side="left", padx=5)
        
        # Chart canvas
        self.chart_container = ctk.CTkFrame(chart_frame)
        self.chart_container.pack(padx=10, pady=10, fill="both", expand=True)
    
    def setup_portfolio_tab(self):
        """Setup portfolio management"""
        tab = self.tabview.tab("Portfolio")
        
        tab.grid_columnconfigure(0, weight=1)
        tab.grid_rowconfigure(1, weight=1)
        
        # Header with refresh
        header_frame = ctk.CTkFrame(tab, fg_color="transparent")
        header_frame.grid(row=0, column=0, padx=10, pady=10, sticky="ew")
        
        ctk.CTkLabel(
            header_frame,
            text="💼 Portfolio Positions",
            font=ctk.CTkFont(size=18, weight="bold")
        ).pack(side="left", padx=10)
        
        ctk.CTkButton(
            header_frame,
            text="🔄 Refresh",
            command=self.refresh_portfolio,
            width=100
        ).pack(side="right", padx=10)
        
        # Positions table
        table_frame = ctk.CTkFrame(tab)
        table_frame.grid(row=1, column=0, padx=10, pady=10, sticky="nsew")
        
        # Create Treeview for positions
        columns = ("Symbol", "Qty", "Entry", "Current", "Value", "P&L", "P&L%")
        
        self.positions_tree = ttk.Treeview(
            table_frame,
            columns=columns,
            show="tree headings",
            height=15
        )
        
        # Configure columns
        self.positions_tree.column("#0", width=0, stretch=False)
        for col in columns:
            self.positions_tree.heading(col, text=col)
            self.positions_tree.column(col, width=100, anchor="center")
        
        # Scrollbar
        scrollbar = ttk.Scrollbar(
            table_frame,
            orient="vertical",
            command=self.positions_tree.yview
        )
        self.positions_tree.configure(yscrollcommand=scrollbar.set)
        
        self.positions_tree.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # Context menu for positions
        self.positions_tree.bind("<Button-3>", self.show_position_menu)
    
    def setup_auto_trading_tab(self):
        """Setup automated trading controls"""
        tab = self.tabview.tab("Auto Trading")
        
        tab.grid_columnconfigure((0, 1), weight=1)
        tab.grid_rowconfigure(1, weight=1)
        
        # Control panel
        control_frame = ctk.CTkFrame(tab)
        control_frame.grid(row=0, column=0, columnspan=2, padx=10, pady=10, sticky="ew")
        
        ctk.CTkLabel(
            control_frame,
            text="🤖 Automated Trading",
            font=ctk.CTkFont(size=18, weight="bold")
        ).pack(pady=10)
        
        # Status
        self.auto_status_label = ctk.CTkLabel(
            control_frame,
            text="Status: STOPPED",
            font=ctk.CTkFont(size=14),
            text_color="red"
        )
        self.auto_status_label.pack(pady=10)
        
        # Control buttons
        button_frame = ctk.CTkFrame(control_frame, fg_color="transparent")
        button_frame.pack(pady=10)
        
        self.start_auto_btn = ctk.CTkButton(
            button_frame,
            text="▶️ Start Auto Trading",
            fg_color="green",
            hover_color="darkgreen",
            command=self.start_auto_trading,
            width=150
        )
        self.start_auto_btn.pack(side="left", padx=5)
        
        self.stop_auto_btn = ctk.CTkButton(
            button_frame,
            text="⏸️ Stop Auto Trading",
            fg_color="red",
            hover_color="darkred",
            command=self.stop_auto_trading,
            width=150,
            state="disabled"
        )
        self.stop_auto_btn.pack(side="left", padx=5)
        
        # Strategy settings
        settings_frame = ctk.CTkFrame(tab)
        settings_frame.grid(row=1, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            settings_frame,
            text="⚙️ Strategy Settings",
            font=ctk.CTkFont(size=14, weight="bold")
        ).pack(pady=10)
        
        # Max positions
        ctk.CTkLabel(settings_frame, text="Max Positions:").pack(pady=(10, 0))
        self.max_positions = ctk.CTkSlider(
            settings_frame,
            from_=1,
            to=10,
            number_of_steps=9
        )
        self.max_positions.pack(pady=5)
        self.max_positions.set(3)
        
        self.max_positions_label = ctk.CTkLabel(settings_frame, text="3")
        self.max_positions_label.pack()
        self.max_positions.configure(
            command=lambda v: self.max_positions_label.configure(text=f"{int(v)}")
        )
        
        # Position size
        ctk.CTkLabel(settings_frame, text="Position Size (%):").pack(pady=(10, 0))
        self.position_size = ctk.CTkSlider(
            settings_frame,
            from_=5,
            to=50,
            number_of_steps=9
        )
        self.position_size.pack(pady=5)
        self.position_size.set(10)
        
        self.position_size_label = ctk.CTkLabel(settings_frame, text="10%")
        self.position_size_label.pack()
        self.position_size.configure(
            command=lambda v: self.position_size_label.configure(text=f"{int(v)}%")
        )
        
        # Stop loss
        ctk.CTkLabel(settings_frame, text="Stop Loss (%):").pack(pady=(10, 0))
        self.stop_loss = ctk.CTkSlider(
            settings_frame,
            from_=2,
            to=20,
            number_of_steps=18
        )
        self.stop_loss.pack(pady=5)
        self.stop_loss.set(8)
        
        self.stop_loss_label = ctk.CTkLabel(settings_frame, text="8%")
        self.stop_loss_label.pack()
        self.stop_loss.configure(
            command=lambda v: self.stop_loss_label.configure(text=f"{int(v)}%")
        )
        
        # Take profit
        ctk.CTkLabel(settings_frame, text="Take Profit (%):").pack(pady=(10, 0))
        self.take_profit = ctk.CTkSlider(
            settings_frame,
            from_=5,
            to=50,
            number_of_steps=9
        )
        self.take_profit.pack(pady=5)
        self.take_profit.set(15)
        
        self.take_profit_label = ctk.CTkLabel(settings_frame, text="15%")
        self.take_profit_label.pack()
        self.take_profit.configure(
            command=lambda v: self.take_profit_label.configure(text=f"{int(v)}%")
        )
        
        # Activity log
        log_frame = ctk.CTkFrame(tab)
        log_frame.grid(row=1, column=1, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            log_frame,
            text="📋 Activity Log",
            font=ctk.CTkFont(size=14, weight="bold")
        ).pack(pady=10)
        
        self.auto_log = ctk.CTkTextbox(log_frame)
        self.auto_log.pack(padx=10, pady=10, fill="both", expand=True)
    
    def setup_analytics_tab(self):
        """Setup analytics and performance tracking"""
        tab = self.tabview.tab("Analytics")
        
        tab.grid_columnconfigure(0, weight=1)
        tab.grid_rowconfigure((0, 1, 2), weight=1)
        
        # Risk Dashboard (NEW)
        risk_frame = ctk.CTkFrame(tab)
        risk_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
        
        from risk_visualization import RiskDashboard
        self.risk_dashboard = RiskDashboard(risk_frame)
        self.risk_dashboard.pack(padx=10, pady=10, fill="both", expand=True)
        
        # Performance metrics
        metrics_frame = ctk.CTkFrame(tab)
        metrics_frame.grid(row=1, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            metrics_frame,
            text="📊 Performance Metrics",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        # Metrics grid
        metrics_grid = ctk.CTkFrame(metrics_frame, fg_color="transparent")
        metrics_grid.pack(padx=20, pady=10, fill="both", expand=True)
        
        metrics_grid.grid_columnconfigure((0, 1, 2), weight=1)
        
        # Total P&L
        pl_frame = ctk.CTkFrame(metrics_grid)
        pl_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
        ctk.CTkLabel(pl_frame, text="Total P&L").pack(pady=5)
        self.total_pl_label = ctk.CTkLabel(
            pl_frame,
            text="$0.00",
            font=ctk.CTkFont(size=20, weight="bold")
        )
        self.total_pl_label.pack(pady=5)
        
        # Win rate
        win_frame = ctk.CTkFrame(metrics_grid)
        win_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
        ctk.CTkLabel(win_frame, text="Win Rate").pack(pady=5)
        self.win_rate_label = ctk.CTkLabel(
            win_frame,
            text="0%",
            font=ctk.CTkFont(size=20, weight="bold")
        )
        self.win_rate_label.pack(pady=5)
        
        # Total trades
        trades_frame = ctk.CTkFrame(metrics_grid)
        trades_frame.grid(row=0, column=2, padx=10, pady=10, sticky="nsew")
        ctk.CTkLabel(trades_frame, text="Total Trades").pack(pady=5)
        self.total_trades_label = ctk.CTkLabel(
            trades_frame,
            text="0",
            font=ctk.CTkFont(size=20, weight="bold")
        )
        self.total_trades_label.pack(pady=5)
        
        # Enhanced Drawdown Chart (NEW)
        chart_frame = ctk.CTkFrame(tab)
        chart_frame.grid(row=2, column=0, padx=10, pady=10, sticky="nsew")
        
        ctk.CTkLabel(
            chart_frame,
            text="📈 Equity Curve & Drawdown Analysis",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        # Initialize enhanced drawdown chart
        from risk_visualization import DrawdownChart
        self.equity_chart = DrawdownChart(chart_frame, width=12, height=5)
        self.equity_chart.pack(padx=10, pady=10, fill="both", expand=True)
    
    def setup_settings_tab(self):
        """Setup application settings"""
        tab = self.tabview.tab("Settings")
        
        tab.grid_columnconfigure(0, weight=1)
        
        # API Configuration
        api_frame = ctk.CTkFrame(tab)
        api_frame.grid(row=0, column=0, padx=20, pady=20, sticky="ew")
        
        ctk.CTkLabel(
            api_frame,
            text="🔑 Alpaca API Configuration",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=10)
        
        ctk.CTkLabel(api_frame, text="API Key:").pack(pady=(10, 0))
        self.api_key_entry = ctk.CTkEntry(api_frame, width=400, show="*")
        self.api_key_entry.pack(pady=5)
        
        ctk.CTkLabel(api_frame, text="API Secret:").pack(pady=(10, 0))
        self.api_secret_entry = ctk.CTkEntry(api_frame, width=400, show="*")
        self.api_secret_entry.pack(pady=5)
        
        # Paper trading toggle
        self.paper_trading_var = ctk.BooleanVar(value=True)
        self.paper_trading_cb = ctk.CTkCheckBox(
            api_frame,
            text="Paper Trading (Recommended)",
            variable=self.paper_trading_var
        )
        self.paper_trading_cb.pack(pady=10)
        
        # Connect button
        self.connect_btn = ctk.CTkButton(
            api_frame,
            text="🔗 Connect to Alpaca",
            command=self.connect_to_alpaca,
            width=200,
            height=40
        )
        self.connect_btn.pack(pady=20)
        
        # Save credentials checkbox
        self.save_creds_var = ctk.BooleanVar(value=True)
        ctk.CTkCheckBox(
            api_frame,
            text="Save credentials (encrypted)",
            variable=self.save_creds_var
        ).pack(pady=5)
        
        # Stock universe settings
        stocks_frame = ctk.CTkFrame(tab)
        stocks_frame.grid(row=1, column=0, padx=20, pady=20, sticky="nsew")
        # Stock universe
        ctk.CTkLabel(
            stocks_frame,
            text="Stock Universe (Symbol - Name):",
            font=ctk.CTkFont(size=12, weight="bold")
        ).pack(pady=(10, 5))
        
        self.stocks_text = ctk.CTkTextbox(stocks_frame, height=300)
        self.stocks_text.pack(padx=10, pady=5, fill="both", expand=True)
        
        # Load saved stock universe if exists
        try:
            if os.path.exists('stock-universe.txt'):
                with open('stock-universe.txt', 'r') as f:
                    saved_universe = f.read()
                    self.stocks_text.insert("1.0", saved_universe)
                    system_logger.info("Loaded stock universe from file")
            else:
                # Default universe from config
                default_text = "\n".join([f"{s} - {n}" for s, n in config.DEFAULT_STOCK_UNIVERSE.items()])
                self.stocks_text.insert("1.0", default_text)
        except Exception as e:
            system_logger.error(f"Failed to load stock universe: {str(e)}")
            # Fallback to config defaults
            default_text = "\n".join([f"{s} - {n}" for s, n in config.DEFAULT_STOCK_UNIVERSE.items()])
            self.stocks_text.insert("1.0", default_text)
        
        ctk.CTkButton(
            stocks_frame,
            text="Save Stock Universe",
            command=self.save_stock_universe
        ).pack(pady=10)
    
    # Event handlers and methods
    
    def check_saved_credentials(self):
        """Check if credentials are saved"""
        if os.path.exists('credentials.enc'):
            try:
                with open('credentials.enc', 'r') as f:
                    creds = json.load(f)
                    self.api_key_entry.insert(0, creds.get('api_key', ''))
                    self.api_secret_entry.insert(0, creds.get('api_secret', ''))
                    self.paper_trading_var.set(creds.get('paper', True))
                
                # Auto-connect
                response = messagebox.askyesno(
                    "Saved Credentials",
                    "Found saved credentials. Connect automatically?"
                )
                if response:
                    self.connect_to_alpaca()
            except:
                pass
    
    def connect_to_alpaca(self):
        """Connect to Alpaca broker with loading indicator"""
        api_key = self.api_key_entry.get().strip()
        api_secret = self.api_secret_entry.get().strip()
        paper = self.paper_trading_var.get()
        
        if not api_key or not api_secret:
            messagebox.showerror("Error", "Please enter API credentials")
            return
        
        # Show loading indicator
        loading_window = ctk.CTkToplevel(self)
        loading_window.title("Loading...")
        loading_window.geometry("400x200")
        loading_window.transient(self)
        loading_window.grab_set()
        
        # Center the loading window
        loading_window.update_idletasks()
        x = (loading_window.winfo_screenwidth() // 2) - (400 // 2)
        y = (loading_window.winfo_screenheight() // 2) - (200 // 2)
        loading_window.geometry(f"400x200+{x}+{y}")
        
        # Loading content
        ctk.CTkLabel(
            loading_window,
            text="🔄 Connecting to Alpaca...",
            font=ctk.CTkFont(size=16, weight="bold")
        ).pack(pady=20)
        
        progress_label = ctk.CTkLabel(
            loading_window,
            text="Initializing connection...",
            font=ctk.CTkFont(size=12)
        )
        progress_label.pack(pady=10)
        
        progress_bar = ctk.CTkProgressBar(loading_window, width=300)
        progress_bar.pack(pady=20)
        progress_bar.set(0.1)
        
        def update_progress(message, value):
            """Update loading progress."""
            progress_label.configure(text=message)
            progress_bar.set(value)
            loading_window.update()
        
        try:
            # Connect to Alpaca
            update_progress("Connecting to Alpaca API...", 0.2)
            self.trader = AlpacaTrader(api_key, api_secret, paper=paper)
            
            update_progress("Verifying account...", 0.4)
            account_info = self.trader.get_account_info()
            
            # Initialize strategy engine
            update_progress("Initializing strategy engine...", 0.5)
            self.strategy_engine = StrategyEngine(self.trader, self.data_manager)
            
            # Initialize risk manager
            update_progress("Setting up risk management...", 0.6)
            if not hasattr(self, 'risk_manager') or self.risk_manager is None:
                self.risk_manager = RiskManager()
            self.risk_manager.set_daily_start_equity(account_info['equity'])
            
            # Load initial data
            update_progress("Loading market data...", 0.7)
            self.refresh_data()
            
            # Start auto-refresh threads
            update_progress("Starting auto-refresh...", 0.9)
            if self.auto_refresh_active and not self.auto_refresh_thread:
                self.start_auto_refresh_threads()
            
            update_progress("Complete! 🎉", 1.0)
            
            # Determine connection mode
            mode = 'PAPER' if paper else 'LIVE'
            
            # Update UI
            self.status_label.configure(
                text=f"● Connected ({mode})",
                text_color="green" if mode == "LIVE" else "orange"
            )
            
            # Update status bar
            if hasattr(self, 'status_bar'):
                self.status_bar.set_connection(connected=True, mode=mode)
                self.status_bar.set_status(f"Connected to Alpaca ({mode} trading)", "success")
            
            # Save credentials if checked
            if self.save_creds_var.get():
                update_progress("Saving credentials...", 0.95)
                with open('credentials.enc', 'w') as f:
                    json.dump({
                        'api_key': api_key,
                        'api_secret': api_secret,
                        'paper': paper
                    }, f)
            
            # Small delay then close loading window
            self.after(500, loading_window.destroy)
            
            messagebox.showinfo(
                "Success",
                f"Connected to Alpaca ({mode} trading)\nAccount ready for trading!"
            )
            
        except Exception as e:
            loading_window.destroy()
            error_msg = str(e)
            messagebox.showerror(
                "Connection Error",
                f"Failed to connect to Alpaca:\n{error_msg}"
            )
            system_logger.error(f"Alpaca connection failed: {error_msg}")
    
    def refresh_data(self):
        """Refresh all account data"""
        if not self.trader:
            messagebox.showwarning("Warning", "Not connected to broker")
            return
        
        threading.Thread(target=self._refresh_data_thread, daemon=True).start()
    
    def _refresh_data_thread(self):
        """Background thread for data refresh"""
        try:
            # Get account info
            account = self.trader.get_account_info()
            
            # Update account displays
            self.update_queue.put(('balance', account['cash_balance']))
            self.update_queue.put(('buying_power', account['buying_power']))
            self.update_queue.put(('day_pl', account['day_pl']))
            
            # Get positions
            positions = self.trader.get_positions()
            self.update_queue.put(('positions_count', len(positions)))
            self.update_queue.put(('portfolio', positions))
            
            # Update portfolio summary on dashboard
            self.update_dashboard_portfolio(account, positions)
            
            # Update market overview
            self.update_market_overview()
            
            # Update analytics charts
            self.update_analytics_charts()
            
            # Log success
            system_logger.debug(f"Data refreshed: {len(positions)} positions")
            
        except Exception as e:
            system_logger.error(f"Refresh error: {str(e)}")
            self.update_queue.put(('error', f"Refresh failed: {str(e)}"))
    
    def show_orders_queue(self):
        """Show Orders & Queue window."""
        try:
            # Import here to avoid circular imports
            from orders_queue_panel import OrdersQueuePanel
            
            system_logger.info("Opening Orders & Queue window...")
            
            # Create window
            queue_window = ctk.CTkToplevel(self)
            queue_window.title("Orders & Queue")
            queue_window.geometry("700x600")
            
            # Center window
            queue_window.update_idletasks()
            x = (queue_window.winfo_screenwidth() // 2) - (700 // 2)
            y = (queue_window.winfo_screenheight() // 2) - (600 // 2)
            queue_window.geometry(f"700x600+{x}+{y}")
            
            # Create panel
            panel = OrdersQueuePanel(
                queue_window,
                trader=self.trader,
                strategy_engine=self.strategy_engine
            )
            panel.pack(fill="both", expand=True, padx=10, pady=10)
            
            # Initial refresh
            panel.refresh()
            
            system_logger.info("Orders & Queue window opened successfully")
            
        except Exception as e:
            error_msg = f"Failed to open Orders & Queue window: {e}"
            system_logger.error(error_msg)
            import traceback
            system_logger.error(traceback.format_exc())
            messagebox.showerror("Error", error_msg)
    
    def scan_markets(self):
        """Scan markets for trading opportunities"""
        if not self.strategy_engine:
            messagebox.showwarning("Warning", "Not connected to broker")
            return
        
        self.log_message("Starting market scan...")
        threading.Thread(target=self._scan_markets_thread, daemon=True).start()
    
    def _scan_markets_thread(self):
        """Background thread for scanning markets"""
        try:
            opportunities = self.strategy_engine.scan_opportunities()
            self.update_queue.put(('scan_results', opportunities))
            self.log_message(f"Scan complete. Found {len(opportunities)} opportunities")
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def place_order(self, side):
        """Place a manual order"""
        if not self.trader:
            messagebox.showwarning("Warning", "Not connected to broker")
            return
        
        symbol = self.symbol_entry.get().strip().upper()
        
        try:
            quantity = int(self.quantity_entry.get().strip())
        except:
            messagebox.showerror("Error", "Invalid quantity")
            return
        
        order_type = self.order_type.get().lower().replace(" ", "_")
        price = self.price_entry.get().strip()
        
        # Confirmation
        response = messagebox.askyesno(
            "Confirm Order",
            f"{side.upper()} {quantity} shares of {symbol}\nOrder Type: {order_type}\n\nConfirm?"
        )
        
        if not response:
            return
        
        threading.Thread(
            target=self._place_order_thread,
            args=(symbol, quantity, side, order_type, price),
            daemon=True
        ).start()
    
    def _place_order_thread(self, symbol, quantity, side, order_type, price):
        """Background thread for placing orders"""
        try:
            order = self.trader.place_order(
                symbol=symbol,
                quantity=quantity,
                side=side,
                order_type=order_type,
                limit_price=float(price) if price else None
            )
            
            self.log_message(f"✓ Order placed: {side.upper()} {quantity} {symbol}")
            self.update_queue.put(('order_success', order))
            
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def get_quote(self):
        """Get real-time quote"""
        symbol = self.symbol_entry.get().strip().upper()
        
        if not symbol:
            return
        
        threading.Thread(target=self._get_quote_thread, args=(symbol,), daemon=True).start()
    
    def _get_quote_thread(self, symbol):
        """Background thread for getting quotes"""
        try:
            quote = self.data_manager.get_quote(symbol)
            price = quote['price']
            change = quote['change']
            change_pct = quote['change_pct']
            
            quote_text = f"{symbol}: ${price:.2f} ({change:+.2f}, {change_pct:+.2%})"
            self.update_queue.put(('quote', quote_text))
            
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def load_chart(self):
        """Load price chart"""
        symbol = self.chart_symbol.get().strip().upper()
        period = self.chart_period.get()
        
        if not symbol:
            return
        
        threading.Thread(target=self._load_chart_thread, args=(symbol, period), daemon=True).start()
    
    def _load_chart_thread(self, symbol, period):
        """Background thread for loading charts"""
        try:
            # Map period to days
            period_map = {
                '1D': 1, '5D': 5, '1M': 30, '3M': 90, '6M': 180, '1Y': 365
            }
            days = period_map.get(period, 30)
            
            df = self.data_manager.get_historical_data(symbol, days)
            
            if df is not None and len(df) > 0:
                self.update_queue.put(('chart', (symbol, df)))
            else:
                self.update_queue.put(('error', f"No data available for {symbol}"))
                
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def refresh_portfolio(self):
        """Refresh portfolio display"""
        if not self.trader:
            return
        
        threading.Thread(target=self._refresh_portfolio_thread, daemon=True).start()
    
    def _refresh_portfolio_thread(self):
        """Background thread for refreshing portfolio"""
        try:
            positions = self.trader.get_positions()
            self.update_queue.put(('portfolio', positions))
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def show_position_menu(self, event):
        """Show context menu for position"""
        item = self.positions_tree.selection()
        if not item:
            return
        
        # Create context menu
        menu = ctk.CTkToplevel(self)
        menu.withdraw()
        menu.overrideredirect(True)
        
        symbol = self.positions_tree.item(item[0])['values'][0]
        
        ctk.CTkButton(
            menu,
            text=f"Close {symbol}",
            command=lambda: self.close_position(symbol)
        ).pack(padx=5, pady=5)
        
        # Position menu at cursor
        x, y = event.x_root, event.y_root
        menu.geometry(f"+{x}+{y}")
        menu.deiconify()
        
        # Auto-hide menu
        menu.after(3000, menu.destroy)
    
    def close_position(self, symbol):
        """Close a position"""
        response = messagebox.askyesno(
            "Close Position",
            f"Close entire position in {symbol}?"
        )
        
        if response:
            self.close_position_action(symbol)
    
    def close_position_action(self, symbol: str):
        """Close a position using Alpaca's close_position API"""
        if not self.trader:
            messagebox.showwarning("Warning", "Not connected to broker")
            return
        
        try:
            # Get position info
            positions = self.trader.get_positions()
            position = next((p for p in positions if p['symbol'] == symbol), None)
            
            if not position:
                messagebox.showwarning("Warning", f"No position found for {symbol}")
                return
            
            # Confirm with user
            qty = position['quantity']
            current_price = position['current_price']
            unrealized_pl = position['unrealized_pl']
            
            msg = (
                f"Close {symbol} position?\n\n"
                f"Quantity: {qty} shares\n"
                f"Current Price: ${current_price:.2f}\n"
                f"Unrealized P&L: ${unrealized_pl:+,.2f}\n\n"
                f"This will close the position and cancel all associated orders."
            )
            
            if not messagebox.askyesno("Confirm Close", msg):
                return
            
            # Use Alpaca's close_position API (handles bracket orders properly)
            success = self.trader.close_position(symbol)
            
            if success:
                messagebox.showinfo(
                    "Success",
                    f"Position {symbol} closed successfully!\nP&L: ${unrealized_pl:+,.2f}"
                )
                
                # Remove from position tracker if exists
                if hasattr(self, 'strategy_engine') and self.strategy_engine:
                    self.strategy_engine.position_tracker.remove_position(symbol)
                
                # Refresh data
                self.refresh_data()
            else:
                messagebox.showerror(
                    "Error",
                    f"Failed to close position {symbol}\nCheck logs for details"
                )
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to close position: {str(e)}")
            system_logger.error(f"Error closing position {symbol}: {e}")
    
    def _close_position_thread(self, symbol):
        """Background thread for closing position"""
        try:
            # Get current position
            positions = self.trader.get_positions()
            position = next((p for p in positions if p['symbol'] == symbol), None)
            
            if position:
                qty = int(position['quantity'])
                self.trader.place_order(symbol, qty, 'sell', 'market')
                self.log_message(f"✓ Closed position: {symbol}")
                
        except Exception as e:
            self.update_queue.put(('error', str(e)))
    
    def start_auto_trading(self):
        """Start automated trading"""
        if not self.trader or not self.strategy_engine:
            messagebox.showwarning("Warning", "Not connected to broker")
            return
        
        response = messagebox.askyesno(
            "Start Auto Trading",
            "Start automated trading?\n\nThe bot will:\n- Scan markets regularly\n- Place trades automatically\n- Manage positions\n\nYou can stop anytime."
        )
        
        if not response:
            return
        
        # Update strategy settings
        self.strategy_engine.max_positions = int(self.max_positions.get())
        self.strategy_engine.position_size = self.position_size.get() / 100
        self.strategy_engine.stop_loss = self.stop_loss.get() / 100
        self.strategy_engine.take_profit = self.take_profit.get() / 100
        
        # Update UI
        self.auto_trading_active = True
        self.auto_status_label.configure(text="Status: RUNNING", text_color="green")
        self.start_auto_btn.configure(state="disabled")
        self.stop_auto_btn.configure(state="normal")
        
        # Start trading thread
        threading.Thread(target=self._auto_trading_loop, daemon=True).start()
        
        self.log_message("✓ Auto trading started")
    
    def stop_auto_trading(self):
        """Stop automated trading"""
        self.auto_trading_active = False
        self.auto_status_label.configure(text="Status: STOPPED", text_color="red")
        self.start_auto_btn.configure(state="normal")
        self.stop_auto_btn.configure(state="disabled")
        
        self.log_message("⏸️ Auto trading stopped")
    
    def _auto_trading_loop(self):
        """Main automated trading loop"""
        while self.auto_trading_active:
            try:
                # Execute strategy
                self.log_message("Running strategy cycle...")
                self.strategy_engine.execute_strategy(dry_run=False)
                
                # Wait before next cycle (5 minutes)
                for _ in range(300):
                    if not self.auto_trading_active:
                        break
                    threading.Event().wait(1)
                    
            except Exception as e:
                self.log_message(f"Error in auto trading: {e}")
                threading.Event().wait(60)  # Wait a minute before retrying
    
    def emergency_stop(self):
        """Emergency stop all trading"""
        response = messagebox.askyesno(
            "Emergency Stop",
            "EMERGENCY STOP\n\nThis will:\n- Stop auto trading\n- Cancel all pending orders\n- Close all positions\n\nContinue?"
        )
        
        if not response:
            return
        
        # Stop auto trading
        self.stop_auto_trading()
        
        # Cancel orders and close positions
        if self.trader:
            threading.Thread(target=self._emergency_stop_thread, daemon=True).start()
    
    def _emergency_stop_thread(self):
        """Background thread for emergency stop"""
        try:
            self.log_message("🛑 EMERGENCY STOP INITIATED")
            
            # Cancel all orders
            self.trader.cancel_all_orders()
            self.log_message("✓ All orders cancelled")
            
            # Close all positions
            positions = self.trader.get_positions()
            for pos in positions:
                symbol = pos['symbol']
                qty = int(pos['quantity'])
                self.trader.place_order(symbol, qty, 'sell', 'market')
                self.log_message(f"✓ Closed position: {symbol}")
            
            self.log_message("🛑 EMERGENCY STOP COMPLETE")
            
        except Exception as e:
            self.log_message(f"Error during emergency stop: {e}")
    
    def save_stock_universe(self):
        """Save custom stock universe"""
        stocks_text = self.stocks_text.get("1.0", "end-1c")
        
        # Parse stocks
        stocks = {}
        for line in stocks_text.split('\n'):
            if '-' in line:
                parts = line.split('-')
                symbol = parts[0].strip()
                name = parts[1].strip()
                stocks[symbol] = name
        
        # Save to data manager
        self.data_manager.stock_universe = stocks
        
        messagebox.showinfo("Success", f"Saved {len(stocks)} stocks")
    
    def change_appearance_mode(self, mode):
        """Change appearance mode"""
        ctk.set_appearance_mode(mode.lower())
    
    def log_message(self, message):
        """Add message to activity log"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        log_entry = f"[{timestamp}] {message}\n"
        self.update_queue.put(('log', log_entry))
    
    def process_updates(self):
        """Process updates from background threads"""
        try:
            while True:
                message = self.update_queue.get_nowait()
                
                # Handle dictionary-style messages from auto-refresh
                if isinstance(message, dict):
                    update_type = message.get('type')
                    data = message.get('data')
                    
                    if update_type == 'account_update':
                        # Update dashboard with account data
                        if hasattr(self, 'balance_label'):
                            self.balance_label.configure(text=f"${data['cash_balance']:,.2f}")
                        if hasattr(self, 'equity_label'):
                            self.equity_label.configure(text=f"Equity: ${data['equity']:,.2f}")
                        if hasattr(self, 'buying_power_label'):
                            self.buying_power_label.configure(text=f"Buying Power: ${data['buying_power']:,.2f}")
                        if hasattr(self, 'day_pl_label'):
                            color = "green" if data['day_pl'] >= 0 else "red"
                            self.day_pl_label.configure(
                                text=f"Day P&L: ${data['day_pl']:,.2f}",
                                text_color=color
                            )
                    
                    elif update_type == 'positions_update':
                        # Update positions table
                        if hasattr(self, 'positions_tree'):
                            self.update_portfolio_table(data)
                        if hasattr(self, 'positions_label'):
                            self.positions_label.configure(text=f"Positions: {len(data)}")
                    
                    elif update_type == 'scan_results':
                        # Update scan results display
                        if hasattr(self, 'signals_text'):
                            self.display_scan_results(data)
                    
                    elif update_type == 'market_status':
                        # Update market status indicator
                        if hasattr(self, 'market_status_label'):
                            status = message.get('status', 'UNKNOWN')
                            event = message.get('next_event', '')
                            time_until = message.get('time_until', '')
                            
                            color = "green" if status == "OPEN" else "gray"
                            status_text = f"Market: {status}"
                            if event and time_until:
                                event_name = "Close" if event == "MARKET_CLOSE" else "Open"
                                status_text += f" | {event_name} in {time_until}"
                            
                            self.market_status_label.configure(
                                text=status_text,
                                text_color=color
                            )
                    
                    continue
                
                # Handle old tuple-style messages
                update_type, data = message
                
                if update_type == 'quote':
                    self.quote_label.configure(text=data)
                
                elif update_type == 'chart':
                    symbol, df = data
                    self.display_chart(symbol, df)
                
                elif update_type == 'dashboard_portfolio':
                    # Update portfolio summary textbox
                    if hasattr(self, 'portfolio_text'):
                        self.portfolio_text.delete("1.0", "end")
                        self.portfolio_text.insert("1.0", data)
                
                elif update_type == 'dashboard_overview':
                    # Update market overview textbox
                    if hasattr(self, 'market_status_text'):
                        self.market_status_text.delete("1.0", "end")
                        self.market_status_text.insert("1.0", data)
                
                elif update_type == 'log':
                    self.auto_log.insert("end", data)
                    self.auto_log.see("end")
                    self.activity_text.insert("end", data)
                    self.activity_text.see("end")
                    # Update status bar
                    if hasattr(self, 'status_bar') and data.strip():
                        self.status_bar.set_status(data.strip(), "info")
                
                elif update_type == 'equity_chart':
                    # Update equity curve chart
                    timestamps, equity_values = data
                    if hasattr(self, 'equity_chart'):
                        self.equity_chart.update(timestamps, equity_values)
                
                elif update_type == 'performance_metrics':
                    # Update performance metrics labels
                    stats = data
                    if hasattr(self, 'total_pl_label'):
                        total_pl = stats.get('total_pnl', 0)
                        color = "green" if total_pl >= 0 else "red"
                        self.total_pl_label.configure(
                            text=f"${total_pl:,.2f}",
                            text_color=color
                        )
                    if hasattr(self, 'win_rate_label'):
                        win_rate = stats.get('win_rate', 0)
                        self.win_rate_label.configure(text=f"{win_rate:.1f}%")
                    if hasattr(self, 'total_trades_label'):
                        total_trades = stats.get('total_trades', 0)
                        self.total_trades_label.configure(text=str(total_trades))
                
                elif update_type == "risk_dashboard":
                    # Update risk dashboard
                    if hasattr(self, 'risk_dashboard'):
                        self.risk_dashboard.update(data)
                
                elif update_type == 'error':
                    messagebox.showerror("Error", data)
        
        except queue.Empty:
            pass
        
        # Schedule next update
        self.after(100, self.process_updates)
    
    def display_chart(self, symbol, df):
        """Display price chart"""
        # Clear previous chart
        for widget in self.chart_container.winfo_children():
            widget.destroy()
        
        # Create figure
        fig = Figure(figsize=(8, 4), dpi=100)
        ax = fig.add_subplot(111)
        
        # Plot price
        ax.plot(df.index, df['Close'], label='Close', linewidth=2)
        ax.fill_between(df.index, df['Low'], df['High'], alpha=0.3)
        
        ax.set_title(f"{symbol} Price Chart", fontsize=12, fontweight='bold')
        ax.set_xlabel("Date")
        ax.set_ylabel("Price ($)")
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        fig.tight_layout()
        
        # Embed in tkinter
        canvas = FigureCanvasTkAgg(fig, master=self.chart_container)
        canvas.draw()
        canvas.get_tk_widget().pack(fill="both", expand=True)
    
    def update_portfolio_table(self, positions):
        """Update portfolio positions table"""
        # Clear existing items
        for item in self.positions_tree.get_children():
            self.positions_tree.delete(item)
        
        # Add positions
        for pos in positions:
            values = (
                pos['symbol'],
                f"{pos['quantity']:.0f}",
                f"${pos['avg_entry_price']:.2f}",
                f"${pos['current_price']:.2f}",
                f"${pos['market_value']:,.2f}",
                f"${pos['unrealized_pl']:,.2f}",
                f"{pos['unrealized_plpc']:.2%}"
            )
            
            # Color code P&L
            tag = 'profit' if pos['unrealized_pl'] >= 0 else 'loss'
            self.positions_tree.insert("", "end", values=values, tags=(tag,))
        
        # Configure tags
        self.positions_tree.tag_configure('profit', foreground='green')
        self.positions_tree.tag_configure('loss', foreground='red')
    
    def update_dashboard_portfolio(self, account, positions):
        """Update portfolio summary on dashboard with enhanced visuals"""
        try:
            portfolio_text = "=" * 45 + "\n"
            portfolio_text += "  💼 ACCOUNT SUMMARY\n"
            portfolio_text += "=" * 45 + "\n"
            portfolio_text += f"Cash:      ${account['cash_balance']:>12,.2f}\n"
            portfolio_text += f"Portfolio: ${account['portfolio_value']:>12,.2f}\n"
            portfolio_text += f"Equity:    ${account['equity']:>12,.2f}\n"
            
            # Day P&L with emoji
            day_pl = account['day_pl']
            if day_pl > 0:
                pl_emoji = "📈"
                pl_sign = "+"
            elif day_pl < 0:
                pl_emoji = "📉"
                pl_sign = ""
            else:
                pl_emoji = "➖"
                pl_sign = " "
            portfolio_text += f"Day P&L:   {pl_emoji} {pl_sign}${day_pl:,.2f}\n\n"
            
            portfolio_text += "=" * 45 + "\n"
            portfolio_text += f"  📊 POSITIONS ({len(positions)})\n"
            portfolio_text += "=" * 45 + "\n"
            
            if positions:
                for pos in positions[:5]:  # Show top 5
                    symbol = pos['symbol']
                    qty = pos['quantity']
                    current = pos['current_price']
                    pnl = pos['unrealized_pl']
                    pnl_pct = pos['unrealized_plpc'] * 100
                    
                    # Position P&L emoji
                    if pnl > 0:
                        pos_emoji = "✅"
                    elif pnl < 0:
                        pos_emoji = "❌"
                    else:
                        pos_emoji = "➖"
                    
                    portfolio_text += f"\n{pos_emoji} {symbol}: {qty:.0f} @ ${current:.2f}\n"
                    portfolio_text += f"   P&L: ${pnl:>8,.2f} ({pnl_pct:>6.2f}%)\n"
            else:
                portfolio_text += "\nNo open positions\n"
            
            # Use queue for thread-safe UI update
            self.update_queue.put(('dashboard_portfolio', portfolio_text))
        except Exception as e:
            system_logger.error(f"Error updating portfolio: {str(e)}")
    
    def update_market_overview(self):
        """Update market overview on dashboard with strategy info"""
        try:
            overview_text = "=" * 45 + "\n"
            overview_text += "  📊 MARKET STATUS\n"
            overview_text += "=" * 45 + "\n"
            
            status = market_hours.get_market_status()
            event, seconds = market_hours.get_next_market_event()
            time_str = market_hours.format_time_remaining(seconds) if seconds else "N/A"
            
            # Market status with emoji
            if status == "OPEN":
                status_emoji = "🟢"
            else:
                status_emoji = "🔴"
            
            overview_text += f"{status_emoji} Status: {status}\n"
            if event:
                event_name = "Close" if event == "MARKET_CLOSE" else "Open"
                overview_text += f"⏰ Next {event_name}: {time_str}\n"
            
            overview_text += f"\n📈 Symbols: {len(self.data_manager.stock_universe)}\n"
            refresh_status = "✅ ON" if self.auto_refresh_active else "❌ OFF"
            overview_text += f"🔄 Auto-Refresh: {refresh_status}\n"
            
            # Strategy Settings
            overview_text += "\n" + "=" * 45 + "\n"
            overview_text += "  ⚙️  STRATEGY SETTINGS\n"
            overview_text += "=" * 45 + "\n"
            
            if hasattr(self, 'strategy_engine'):
                strategy = self.strategy_engine
                overview_text += f"Max Positions: {strategy.max_positions}\n"
                overview_text += f"Position Size: {strategy.position_size*100:.0f}% of equity\n"
                overview_text += f"Risk/Trade: {config.RISK_PER_TRADE*100:.1f}%\n"
                overview_text += f"\n🎯 ADX Filter: {'ON' if config.USE_ADX_FILTER else 'OFF'}\n"
                if config.USE_ADX_FILTER:
                    overview_text += f"   Min ADX: {config.MIN_ADX_FOR_TRADE}\n"
                overview_text += f"\n💨 ATR Sizing: {'ON' if config.USE_ATR_POSITION_SIZING else 'OFF'}\n"
                if config.USE_ATR_POSITION_SIZING:
                    overview_text += f"   Stop: {config.ATR_STOP_MULTIPLIER}x ATR\n"
                    overview_text += f"   Target: {config.ATR_TARGET_MULTIPLIER}x ATR\n"
            
            # Use queue for thread-safe UI update
            self.update_queue.put(('dashboard_overview', overview_text))
        except Exception as e:
            system_logger.error(f"Error updating market overview: {str(e)}")
    
    def update_analytics_charts(self):
        """Update analytics charts with latest data"""
        try:
            # Get portfolio snapshots from database (correct method name)
            snapshots = self.database.get_portfolio_history(days=30)
            
            if snapshots and len(snapshots) > 0:
                # Extract timestamps and equity values
                timestamps = [snapshot['timestamp'] for snapshot in snapshots]
                equity_values = [snapshot['equity'] for snapshot in snapshots]
                
                # Update equity chart via queue (thread-safe)
                self.update_queue.put(('equity_chart', (timestamps, equity_values)))
                
                # Calculate and update performance metrics (correct method name)
                stats = self.database.get_trading_statistics()
                if stats:
                    # Map to expected format for UI
                    performance_stats = {
                        'total_pnl': stats.get('total_pl', 0),
                        'win_rate': stats.get('win_rate', 0),
                        'total_trades': stats.get('total_trades', 0)
                    }
                    self.update_queue.put(('performance_metrics', performance_stats))
                
                # Update risk dashboard with latest risk report
                if hasattr(self, 'trader') and self.trader.api:
                    try:
                        account = self.trader.get_account_info()
                        positions = self.trader.get_positions()
                        if account and hasattr(self, 'strategy_engine'):
                            risk_report = self.strategy_engine.risk_manager.get_risk_report(account, positions)
                            self.update_queue.put(('risk_dashboard', risk_report))
                    except Exception as e:
                        system_logger.debug(f"Could not update risk dashboard: {str(e)}")
                
                system_logger.debug(f"Analytics charts updated with {len(snapshots)} data points")
            else:
                system_logger.debug("No portfolio snapshots available for chart update")
                
        except Exception as e:
            system_logger.error(f"Error updating analytics charts: {str(e)}")
    
    def _update_textbox(self, textbox, content):
        """Safely update textbox content"""
        try:
            textbox.delete("1.0", "end")
            textbox.insert("1.0", content)
        except:
            pass
    
    def display_scan_results(self, opportunities):
        """Display market scan results with enhanced metrics"""
        self.signals_text.delete("1.0", "end")
        
        if not opportunities:
            self.signals_text.insert("1.0", "No opportunities found")
            return
        
        # Header
        header = "=" * 50 + "\n"
        header += "  TRADING OPPORTUNITIES (Top 10)\n"
        header += "=" * 50 + "\n\n"
        self.signals_text.insert("end", header)
        
        for i, opp in enumerate(opportunities[:10], 1):
            # Action emoji and symbol
            emoji = "📈" if opp['action'] == 'BUY' else "📉"
            
            # Trend strength emoji and color coding
            adx = opp.get('adx', 0)
            trend_strength = opp.get('trend_strength', 'UNKNOWN')
            
            if trend_strength == 'WEAK':
                trend_emoji = "⚪"  # Weak
                conf_color = "gray"
            elif trend_strength == 'DEVELOPING':
                trend_emoji = "🟡"  # Developing
                conf_color = "yellow"
            elif trend_strength == 'STRONG':
                trend_emoji = "🟢"  # Strong
                conf_color = "green"
            else:  # VERY_STRONG
                trend_emoji = "🔴"  # Very strong (possibly exhaustion)
                conf_color = "orange"
            
            # Confidence level
            confidence = opp['confidence']
            if confidence >= 75:
                conf_emoji = "🔥"  # High confidence
            elif confidence >= 50:
                conf_emoji = "✅"  # Good confidence  
            else:
                conf_emoji = "⚠️"  # Lower confidence
            
            # Build display string
            text = f"{i}. {emoji} {opp['symbol']} - {opp['action']} {conf_emoji}\n"
            text += f"   Price: ${opp['price']:.2f} | Confidence: {confidence:.0f}%\n"
            
            # ADX and Trend Strength
            text += f"   {trend_emoji} Trend: {trend_strength} (ADX: {adx:.1f})\n"
            
            # ATR Volatility
            atr_pct = opp.get('atr_percent', 0)
            atr = opp.get('atr', 0)
            if atr > 0:
                text += f"   💨 Volatility: {atr_pct:.1f}% (ATR: ${atr:.2f})\n"
            
            # RSI
            rsi = opp.get('rsi', 0)
            if rsi > 0:
                if rsi < 30:
                    rsi_status = "OVERSOLD 📊"
                elif rsi > 70:
                    rsi_status = "OVERBOUGHT 📊"
                else:
                    rsi_status = f"{rsi:.0f}"
                text += f"   RSI: {rsi_status}\n"
            
            # Signals summary
            signals = opp.get('signals', [])
            if signals:
                text += f"   Signals: {', '.join(signals[:3])}\n"
            
            text += "\n"
            
            self.signals_text.insert("end", text)
    
    def handle_notification(self, notification):
        """
        Handle notifications from the notification system.
        
        Args:
            notification: Notification object
        """
        try:
            # Add to activity log if exists
            if hasattr(self, 'activity_text'):
                timestamp = notification.timestamp.strftime("%H:%M:%S")
                msg = f"[{timestamp}] {notification.title}: {notification.message}\n"
                self.activity_text.insert("1.0", msg)
                
                # Limit text size
                lines = self.activity_text.get("1.0", "end").split("\n")
                if len(lines) > 100:
                    self.activity_text.delete(f"{len(lines)-99}.0", "end")
        except Exception as e:
            system_logger.error(f"Error handling notification: {str(e)}")
    
    def save_stock_universe(self):
        """Save stock universe from settings"""
        try:
            text = self.stocks_text.get("1.0", "end").strip()
            lines = text.split("\n")
            
            universe = {}
            for line in lines:
                if " - " in line:
                    parts = line.split(" - ")
                    symbol = parts[0].strip().upper()
                    name = parts[1].strip()
                    universe[symbol] = name
            
            if universe:
                # Update data manager
                self.data_manager.update_stock_universe(universe)
                
                # Save to file for persistence
                with open('stock-universe.txt', 'w') as f:
                    for symbol, name in universe.items():
                        f.write(f"{symbol} - {name}\n")
                
                messagebox.showinfo("Success", f"Saved {len(universe)} stocks to universe")
                notification_system.info(
                    "Stock Universe Updated",
                    f"Loaded {len(universe)} symbols (saved to file)",
                    category="SYSTEM"
                )
                system_logger.info(f"Stock universe saved: {len(universe)} symbols")
            else:
                messagebox.showwarning("Warning", "No valid stocks found")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to save stock universe: {str(e)}")
            system_logger.error(f"Failed to save stock universe: {str(e)}")
    
    def start_auto_refresh_threads(self):
        """Start background threads for auto-refresh"""
        if not self.auto_refresh_active:
            return
        
        system_logger.info("Starting auto-refresh threads...")
        
        # Data refresh thread
        self.auto_refresh_thread = threading.Thread(
            target=self._auto_refresh_loop,
            daemon=True,
            name="AutoRefresh"
        )
        self.auto_refresh_thread.start()
        
        # Market scan thread
        self.auto_scan_thread = threading.Thread(
            target=self._auto_scan_loop,
            daemon=True,
            name="AutoScan"
        )
        self.auto_scan_thread.start()
        
        # Dashboard update thread
        self.dashboard_update_thread = threading.Thread(
            target=self._dashboard_update_loop,
            daemon=True,
            name="DashboardUpdate"
        )
        self.dashboard_update_thread.start()
        
        notification_system.info(
            "Auto-Refresh Started",
            "Continuous updates enabled",
            category="SYSTEM"
        )
    
    def stop_auto_refresh_threads(self):
        """Stop background auto-refresh threads"""
        system_logger.info("Stopping auto-refresh threads...")
        self._stop_auto_threads.set()
        self.auto_refresh_active = False
    
    def _auto_refresh_loop(self):
        """Background thread for automatic data refresh"""
        while not self._stop_auto_threads.is_set():
            try:
                if self.trader:
                    # Refresh account data
                    account = self.trader.get_account_info()
                    positions = self.trader.get_positions()
                    
                    # Update displays via queue
                    self.update_queue.put({
                        'type': 'account_update',
                        'data': account
                    })
                    self.update_queue.put({
                        'type': 'positions_update',
                        'data': positions
                    })
                    
                    # Save snapshot to database
                    self.database.save_portfolio_snapshot(account, positions)
                    
                    # Update dashboard displays
                    self.update_dashboard_portfolio(account, positions)
                    self.update_market_overview()
                    
                    # Update analytics charts
                    self.update_analytics_charts()
                    
                    # Monitor positions and update trailing stops (NEW)
                    if hasattr(self, 'strategy_engine') and self.strategy_engine:
                        self.strategy_engine.monitor_positions()
                    
                    system_logger.debug("Auto-refresh: Data updated")
                    
            except Exception as e:
                system_logger.error(f"Auto-refresh error: {str(e)}")
            
            # Wait for next refresh
            self._stop_auto_threads.wait(config.AUTO_REFRESH_INTERVAL)
    
    def _auto_scan_loop(self):
        """Background thread for automatic market scanning"""
        while not self._stop_auto_threads.is_set():
            try:
                # Only scan during market hours
                if market_hours.is_market_open() and self.strategy_engine:
                    trading_logger.info("Auto-scan: Scanning markets...")
                    
                    opportunities = self.strategy_engine.scan_opportunities()
                    
                    # Update UI via queue
                    self.update_queue.put({
                        'type': 'scan_results',
                        'data': opportunities
                    })
                    
                    trading_logger.info(f"Auto-scan: Found {len(opportunities)} opportunities")
                    
            except Exception as e:
                system_logger.error(f"Auto-scan error: {str(e)}")
            
            # Wait for next scan
            self._stop_auto_threads.wait(config.AUTO_SCAN_INTERVAL)
    
    def _dashboard_update_loop(self):
        """Background thread for dashboard updates"""
        while not self._stop_auto_threads.is_set():
            try:
                if self.trader:
                    # Get market status
                    status = market_hours.get_market_status()
                    event, seconds = market_hours.get_next_market_event()
                    time_str = market_hours.format_time_remaining(seconds) if seconds else "N/A"
                    
                    # Update market status display via queue
                    self.update_queue.put({
                        'type': 'market_status',
                        'status': status,
                        'next_event': event,
                        'time_until': time_str
                    })
                    
            except Exception as e:
                system_logger.error(f"Dashboard update error: {str(e)}")
            
            # Update more frequently
            self._stop_auto_threads.wait(config.DASHBOARD_UPDATE_INTERVAL)
    
    def open_transaction_history(self):
        """Open transaction history viewer window"""
        try:
            open_transaction_viewer(self, self.database)
            system_logger.info("Transaction history opened via shortcut")
        except Exception as e:
            system_logger.error(f"Failed to open transaction history: {str(e)}")
            messagebox.showerror("Error", f"Failed to open transaction history: {str(e)}")
    
    def show_help(self):
        """Show keyboard shortcuts help"""
        help_text = """
🎯 Keyboard Shortcuts:

Ctrl + R  - Refresh Data
Ctrl + H  - Transaction History
Ctrl + Q  - Quit Application
F1        - Show This Help

📊 Features:

Auto-Refresh: Data updates every 60 seconds
Market Scanning: Automatic during market hours
Transaction History: Full trade tracking with analytics

For more help, see README.md
        """
        messagebox.showinfo("Help - Keyboard Shortcuts", help_text)
    
    def on_closing(self):
        """Handle application closing"""
        try:
            # Stop auto-refresh threads
            if self.auto_refresh_active:
                self.stop_auto_refresh_threads()
            
            # Stop auto trading if active
            if self.auto_trading_active:
                self.stop_auto_trading()
            
            # Save final portfolio snapshot if connected
            if self.trader:
                try:
                    account = self.trader.get_account_info()
                    positions = self.trader.get_positions()
                    self.database.save_portfolio_snapshot(account, positions)
                except:
                    pass
            
            # Log shutdown
            system_logger.info("Application shutting down")
            notification_system.info("System", "Application closing", category="SYSTEM")
            
            # Close window
            self.destroy()
            
        except Exception as e:
            system_logger.error(f"Error during shutdown: {str(e)}")
            self.destroy()


def main():
    """Main entry point"""
    try:
        app = TradingPlatform()
        app.mainloop()
    except Exception as e:
        system_logger.critical(f"Fatal error: {str(e)}")
        raise


if __name__ == "__main__":
    main()