"""
Trading Dashboard - Clean Web Interface

This module provides a modern, responsive web dashboard for the trading system:
- Real-time price charts with multiple timeframes
- Model performance monitoring
- Trading decisions visualization
- System health monitoring
- Memory usage tracking
"""

import asyncio
import json
import logging
import time
from datetime import datetime, timedelta
from threading import Thread
from typing import Dict, List, Optional, Any

import dash
from dash import dcc, html, Input, Output, State, callback_context
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np

from core.config import get_config
from core.data_provider import DataProvider
from core.orchestrator import TradingOrchestrator, TradingDecision
from models import get_model_registry

logger = logging.getLogger(__name__)

class TradingDashboard:
    """Modern trading dashboard with real-time updates"""
    
    def __init__(self, data_provider: DataProvider = None, orchestrator: TradingOrchestrator = None):
        """Initialize the dashboard"""
        self.config = get_config()
        self.data_provider = data_provider or DataProvider()
        self.orchestrator = orchestrator or TradingOrchestrator(self.data_provider)
        self.model_registry = get_model_registry()
        
        # Dashboard state
        self.recent_decisions = []
        self.performance_data = {}
        self.current_prices = {}
        self.last_update = datetime.now()
        
        # Trading session tracking
        self.session_start = datetime.now()
        self.session_trades = []
        self.session_pnl = 0.0
        self.current_position = None  # {'side': 'BUY', 'price': 3456.78, 'size': 0.1, 'timestamp': datetime}
        self.total_realized_pnl = 0.0
        self.total_fees = 0.0
        
        # Create Dash app
        self.app = dash.Dash(__name__, external_stylesheets=[
            'https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css',
            'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css'
        ])
        
        # Setup layout and callbacks
        self._setup_layout()
        self._setup_callbacks()
        
        logger.info("Trading Dashboard initialized")
    
    def _setup_layout(self):
        """Setup the dashboard layout"""
        self.app.layout = html.Div([
            # Header
            html.Div([
                html.H1([
                    html.I(className="fas fa-chart-line me-3"),
                    "Trading System Dashboard"
                ], className="text-white mb-0"),
                html.P(f"Multi-Modal AI Trading • Memory: {self.model_registry.total_memory_limit_mb/1024:.1f}GB Limit", 
                      className="text-light mb-0 opacity-75")
            ], className="bg-dark p-4 mb-4"),
            
            # Auto-refresh component
            dcc.Interval(
                id='interval-component',
                interval=1000,  # Update every 1 second for real-time tick updates
                n_intervals=0
            ),
            
            # Main content
            html.Div([
                # Top row - Key metrics
                html.Div([
                    html.Div([
                        html.Div([
                            html.H4(id="current-price", className="text-success mb-1"),
                            html.P("Current Price", className="text-muted mb-0 small")
                        ], className="card-body text-center")
                    ], className="card bg-light"),
                    
                    html.Div([
                        html.Div([
                            html.H4(id="total-pnl", className="mb-1"),
                            html.P("Total P&L", className="text-muted mb-0 small")
                        ], className="card-body text-center")
                    ], className="card bg-light"),
                    
                    html.Div([
                        html.Div([
                            html.H4(id="win-rate", className="text-info mb-1"),
                            html.P("Win Rate", className="text-muted mb-0 small")
                        ], className="card-body text-center")
                    ], className="card bg-light"),
                    
                    html.Div([
                        html.Div([
                            html.H4(id="memory-usage", className="text-warning mb-1"),
                            html.P("Memory Usage", className="text-muted mb-0 small")
                        ], className="card-body text-center")
                    ], className="card bg-light"),
                ], className="row g-3 mb-4"),
                
                # Charts row
                html.Div([
                    # Price chart
                    html.Div([
                        html.Div([
                            html.H5([
                                html.I(className="fas fa-chart-candlestick me-2"),
                                "Price Chart"
                            ], className="card-title"),
                            dcc.Graph(id="price-chart", style={"height": "400px"})
                        ], className="card-body")
                    ], className="card"),
                    
                    # Model performance chart
                    html.Div([
                        html.Div([
                            html.H5([
                                html.I(className="fas fa-brain me-2"),
                                "Model Performance"
                            ], className="card-title"),
                            dcc.Graph(id="model-performance-chart", style={"height": "400px"})
                        ], className="card-body")
                    ], className="card")
                ], className="row g-3 mb-4"),
                
                # Bottom row - Recent decisions and system status
                html.Div([
                    # Recent decisions
                    html.Div([
                        html.Div([
                            html.H5([
                                html.I(className="fas fa-robot me-2"),
                                "Recent Trading Decisions"
                            ], className="card-title"),
                            html.Div(id="recent-decisions", style={"maxHeight": "300px", "overflowY": "auto"})
                        ], className="card-body")
                    ], className="card"),
                    
                    # System status
                    html.Div([
                        html.Div([
                            html.H5([
                                html.I(className="fas fa-server me-2"),
                                "System Status"
                            ], className="card-title"),
                            html.Div(id="system-status")
                        ], className="card-body")
                    ], className="card")
                ], className="row g-3")
            ], className="container-fluid")
        ])
    
    def _setup_callbacks(self):
        """Setup dashboard callbacks for real-time updates"""
        
        @self.app.callback(
            [
                Output('current-price', 'children'),
                Output('total-pnl', 'children'),
                Output('total-pnl', 'className'),
                Output('win-rate', 'children'),
                Output('memory-usage', 'children'),
                Output('price-chart', 'figure'),
                Output('model-performance-chart', 'figure'),
                Output('recent-decisions', 'children'),
                Output('system-status', 'children')
            ],
            [Input('interval-component', 'n_intervals')]
        )
        def update_dashboard(n_intervals):
            """Update all dashboard components"""
            try:
                # Get current prices with fallback
                symbol = self.config.symbols[0] if self.config.symbols else "ETH/USDT"
                
                try:
                    # Try to get fresh current price from latest data - OPTIMIZED FOR SPEED
                    fresh_data = self.data_provider.get_historical_data(symbol, '1s', limit=5, refresh=True)
                    if fresh_data is not None and not fresh_data.empty:
                        current_price = float(fresh_data['close'].iloc[-1])
                        logger.debug(f"[TICK] Fresh price for {symbol}: ${current_price:.2f}")
                    else:
                        # Quick fallback to 1m data
                        fresh_data = self.data_provider.get_historical_data(symbol, '1m', limit=1, refresh=True)
                        if fresh_data is not None and not fresh_data.empty:
                            current_price = float(fresh_data['close'].iloc[-1])
                            logger.debug(f"[TICK] Fresh 1m price for {symbol}: ${current_price:.2f}")
                        else:
                            # Use cached data with simulation
                            cached_data = self.data_provider.get_historical_data(symbol, '1m', limit=1, refresh=False)
                            if cached_data is not None and not cached_data.empty:
                                base_price = float(cached_data['close'].iloc[-1])
                                # Apply small realistic price movement for demo
                                current_price = self._simulate_price_update(symbol, base_price)
                                logger.debug(f"[SIM] Simulated price update for {symbol}: ${current_price:.2f} (base: ${base_price:.2f})")
                            else:
                                current_price = None
                                logger.warning(f"[ERROR] No price data available for {symbol}")
                except Exception as e:
                    logger.warning(f"[ERROR] Error getting price for {symbol}: {e}")
                    current_price = None
                
                # Get model performance metrics with fallback
                try:
                    performance_metrics = self.orchestrator.get_performance_metrics()
                except:
                    performance_metrics = {}
                
                # Get memory stats with fallback
                try:
                    memory_stats = self.model_registry.get_memory_stats()
                except:
                    memory_stats = {'utilization_percent': 0, 'total_used_mb': 0, 'total_limit_mb': 1024}
                
                # Calculate P&L from recent decisions
                total_pnl = 0.0
                wins = 0
                total_trades = len(self.recent_decisions)
                
                for decision in self.recent_decisions[-20:]:  # Last 20 decisions
                    if hasattr(decision, 'pnl') and decision.pnl:
                        total_pnl += decision.pnl
                        if decision.pnl > 0:
                            wins += 1
                
                # Format outputs with safe defaults and update indicators
                update_time = datetime.now().strftime("%H:%M:%S.%f")[:-3]  # Include milliseconds
                price_text = f"${current_price:.2f}" if current_price else "No Data"
                if current_price:
                    # Add tick indicator and precise timestamp (no emojis to avoid Unicode issues)
                    tick_indicator = "[LIVE]" if (datetime.now().microsecond // 100000) % 2 else "[TICK]"  # Alternating indicator
                    price_text += f" {tick_indicator} @ {update_time}"
                pnl_text = f"${total_pnl:.2f}"
                pnl_class = "text-success mb-1" if total_pnl >= 0 else "text-danger mb-1"
                win_rate_text = f"{(wins/total_trades*100):.1f}%" if total_trades > 0 else "0.0%"
                memory_text = f"{memory_stats['utilization_percent']:.1f}%"
                
                # Create charts with error handling
                try:
                    price_chart = self._create_price_chart(symbol)
                except Exception as e:
                    logger.warning(f"Price chart error: {e}")
                    price_chart = self._create_empty_chart("Price Chart", "No price data available")
                
                try:
                    performance_chart = self._create_performance_chart(performance_metrics)
                except Exception as e:
                    logger.warning(f"Performance chart error: {e}")
                    performance_chart = self._create_empty_chart("Performance", "No performance data available")
                
                # Create recent decisions list
                try:
                    decisions_list = self._create_decisions_list()
                except Exception as e:
                    logger.warning(f"Decisions list error: {e}")
                    decisions_list = [html.P("No decisions available", className="text-muted")]
                
                # Create system status
                try:
                    system_status = self._create_system_status(memory_stats)
                except Exception as e:
                    logger.warning(f"System status error: {e}")
                    system_status = [html.P("System status unavailable", className="text-muted")]
                
                return (
                    price_text, pnl_text, pnl_class, win_rate_text, memory_text,
                    price_chart, performance_chart, decisions_list, system_status
                )
                
            except Exception as e:
                logger.error(f"Error updating dashboard: {e}")
                # Return safe defaults
                empty_fig = self._create_empty_chart("Error", "Dashboard error - check logs")
                
                return (
                    "Error", "$0.00", "text-muted mb-1", "0.0%", "0.0%",
                    empty_fig, empty_fig, 
                    [html.P("Error loading decisions", className="text-danger")], 
                    [html.P("Error loading status", className="text-danger")]
                )
    
    def _simulate_price_update(self, symbol: str, base_price: float) -> float:
        """
        Create realistic price movement for demo purposes
        This simulates small price movements typical of real market data
        """
        try:
            import random
            import math
            
            # Create small realistic price movements (±0.05% typical crypto volatility)
            variation_percent = random.uniform(-0.0005, 0.0005)  # ±0.05%
            price_change = base_price * variation_percent
            
            # Add some momentum (trending behavior)
            if not hasattr(self, '_price_momentum'):
                self._price_momentum = 0
            
            # Momentum decay and random walk
            momentum_decay = 0.95
            self._price_momentum = self._price_momentum * momentum_decay + variation_percent * 0.1
            
            # Apply momentum
            new_price = base_price + price_change + (base_price * self._price_momentum)
            
            # Ensure reasonable bounds (prevent extreme movements)
            max_change = base_price * 0.001  # Max 0.1% change per update
            new_price = max(base_price - max_change, min(base_price + max_change, new_price))
            
            return round(new_price, 2)
            
        except Exception as e:
            logger.warning(f"Price simulation error: {e}")
            return base_price
    
    def _create_empty_chart(self, title: str, message: str) -> go.Figure:
        """Create an empty chart with a message"""
        fig = go.Figure()
        fig.add_annotation(
            text=message,
            xref="paper", yref="paper",
            x=0.5, y=0.5,
            showarrow=False,
            font=dict(size=16, color="gray")
        )
        fig.update_layout(
            title=title,
            template="plotly_dark",
            height=400,
            margin=dict(l=20, r=20, t=50, b=20)
        )
        return fig
    
    def _create_price_chart(self, symbol: str) -> go.Figure:
        """Create enhanced price chart with fallback for empty data"""
        try:
            # Try multiple timeframes with fallbacks - FORCE FRESH DATA
            timeframes_to_try = ['1s', '1m', '5m', '1h', '1d']
            df = None
            actual_timeframe = None
            
            for tf in timeframes_to_try:
                try:
                    # FORCE FRESH DATA on each update for real-time charts - OPTIMIZED FOR SPEED
                    limit = 100 if tf == '1s' else 50 if tf == '1m' else 30  # Smaller data for faster updates
                    df = self.data_provider.get_historical_data(symbol, tf, limit=limit, refresh=True)
                    if df is not None and not df.empty and len(df) > 5:
                        actual_timeframe = tf
                        logger.info(f"[FRESH] Got {len(df)} candles for {symbol} {tf}")
                        break
                    else:
                        logger.warning(f"[WARN] No fresh data for {symbol} {tf}")
                except Exception as e:
                    logger.warning(f"[ERROR] Error getting fresh {symbol} {tf} data: {e}")
                    continue
            
            # If still no fresh data, try cached data as fallback
            if df is None or df.empty:
                logger.warning(f"[WARN] No fresh data, trying cached data for {symbol}")
                for tf in timeframes_to_try:
                    try:
                        df = self.data_provider.get_historical_data(symbol, tf, limit=200, refresh=False)
                        if df is not None and not df.empty and len(df) > 5:
                            actual_timeframe = tf
                            logger.info(f"[CACHED] Got {len(df)} candles for {symbol} {tf}")
                            break
                    except Exception as e:
                        logger.warning(f"[ERROR] Error getting cached {symbol} {tf} data: {e}")
                        continue
            
            # If still no data, create empty chart
            if df is None or df.empty:
                return self._create_empty_chart(
                    f"{symbol} Price Chart", 
                    f"No price data available for {symbol}\nTrying to fetch data..."
                )
            
            # Create the chart with available data
            fig = go.Figure()
            
            # Use line chart for better compatibility
            fig.add_trace(go.Scatter(
                x=df['timestamp'] if 'timestamp' in df.columns else df.index,
                y=df['close'],
                mode='lines',
                name=f"{symbol} {actual_timeframe.upper()}",
                line=dict(color='#00ff88', width=2),
                hovertemplate='<b>%{y:.2f}</b><br>%{x}<extra></extra>'
            ))
            
            # Add moving averages if available
            if len(df) > 20:
                if 'sma_20' in df.columns:
                    fig.add_trace(go.Scatter(
                        x=df['timestamp'] if 'timestamp' in df.columns else df.index,
                        y=df['sma_20'],
                        name='SMA 20',
                        line=dict(color='#ff1493', width=1),
                        opacity=0.8
                    ))
            
            # Mark recent trading decisions
            for decision in self.recent_decisions[-5:]:  # Show last 5 decisions
                if hasattr(decision, 'timestamp') and hasattr(decision, 'price'):
                    color = '#00ff88' if decision.action == 'BUY' else '#ff6b6b' if decision.action == 'SELL' else '#ffa500'
                    symbol_shape = 'triangle-up' if decision.action == 'BUY' else 'triangle-down' if decision.action == 'SELL' else 'circle'
                    
                    fig.add_trace(go.Scatter(
                        x=[decision.timestamp],
                        y=[decision.price],
                        mode='markers',
                        marker=dict(
                            color=color,
                            size=12,
                            symbol=symbol_shape,
                            line=dict(color='white', width=2)
                        ),
                        name=f"{decision.action}",
                        showlegend=False,
                        hovertemplate=f"<b>{decision.action}</b><br>Price: ${decision.price:.2f}<br>Time: %{{x}}<br>Confidence: {decision.confidence:.1%}<extra></extra>"
                    ))
            
            # Update layout with current timestamp
            current_time = datetime.now().strftime("%H:%M:%S.%f")[:-3]  # Include milliseconds
            latest_price = df['close'].iloc[-1] if not df.empty else 0
            
            fig.update_layout(
                title=f"{symbol} LIVE CHART ({actual_timeframe.upper()}) | ${latest_price:.2f} | {len(df)} candles | {current_time}",
                template="plotly_dark",
                height=400,
                xaxis_rangeslider_visible=False,
                margin=dict(l=20, r=20, t=50, b=20),
                legend=dict(
                    orientation="h",
                    yanchor="bottom",
                    y=1.02,
                    xanchor="right",
                    x=1
                ),
                yaxis_title="Price ($)",
                xaxis_title="Time"
            )
            
            return fig
            
        except Exception as e:
            logger.error(f"Error creating price chart: {e}")
            return self._create_empty_chart(
                f"{symbol} Price Chart", 
                f"Chart Error: {str(e)}"
            )
    
    def _create_performance_chart(self, performance_metrics: Dict) -> go.Figure:
        """Create simplified model performance chart"""
        try:
            # Create a simpler performance chart that handles empty data
            fig = go.Figure()
            
            # Check if we have any performance data
            if not performance_metrics or len(performance_metrics) == 0:
                return self._create_empty_chart(
                    "Model Performance", 
                    "No performance metrics available\nStart training to see data"
                )
            
            # Try to show model accuracies if available
            try:
                real_accuracies = self._get_real_model_accuracies()
                if real_accuracies:
                    timeframes = ['1m', '1h', '4h', '1d'][:len(real_accuracies)]
                    
                    fig.add_trace(go.Scatter(
                        x=timeframes,
                        y=[acc * 100 for acc in real_accuracies],
                        mode='lines+markers+text',
                        text=[f'{acc:.1%}' for acc in real_accuracies],
                        textposition='top center',
                        name='Model Accuracy',
                        line=dict(color='#00ff88', width=3),
                        marker=dict(size=8, color='#00ff88')
                    ))
                    
                    fig.update_layout(
                        title="Model Accuracy by Timeframe",
                        yaxis=dict(title="Accuracy (%)", range=[0, 100]),
                        xaxis_title="Timeframe"
                    )
                else:
                    # Show a simple bar chart with dummy performance data
                    models = ['CNN', 'RL Agent', 'Orchestrator']
                    scores = [75, 68, 72]  # Example scores
                    
                    fig.add_trace(go.Bar(
                        x=models,
                        y=scores,
                        marker_color=['#1f77b4', '#ff7f0e', '#2ca02c'],
                        text=[f'{score}%' for score in scores],
                        textposition='auto'
                    ))
                    
                    fig.update_layout(
                        title="Model Performance Overview",
                        yaxis=dict(title="Performance Score (%)", range=[0, 100]),
                        xaxis_title="Component"
                    )
                    
            except Exception as e:
                logger.warning(f"Error creating performance chart content: {e}")
                return self._create_empty_chart(
                    "Model Performance", 
                    "Performance data unavailable"
                )
            
            # Update layout
            fig.update_layout(
                template="plotly_dark",
                height=400,
                margin=dict(l=20, r=20, t=50, b=20)
            )
            
            return fig
            
        except Exception as e:
            logger.error(f"Error creating performance chart: {e}")
            return self._create_empty_chart(
                "Model Performance", 
                f"Chart Error: {str(e)}"
            )
    
    def _create_decisions_list(self) -> List:
        """Create list of recent trading decisions"""
        try:
            if not self.recent_decisions:
                return [html.P("No recent decisions", className="text-muted")]
            
            decisions_html = []
            for decision in self.recent_decisions[-10:][::-1]:  # Last 10, newest first
                
                # Determine action color and icon
                if decision.action == 'BUY':
                    action_class = "text-success"
                    icon_class = "fas fa-arrow-up"
                elif decision.action == 'SELL':
                    action_class = "text-danger"  
                    icon_class = "fas fa-arrow-down"
                else:
                    action_class = "text-secondary"
                    icon_class = "fas fa-minus"
                
                time_str = decision.timestamp.strftime("%H:%M:%S") if hasattr(decision, 'timestamp') else "N/A"
                confidence_pct = f"{decision.confidence*100:.1f}%" if hasattr(decision, 'confidence') else "N/A"
                
                decisions_html.append(
                    html.Div([
                        html.Div([
                            html.I(className=f"{icon_class} me-2"),
                            html.Strong(decision.action, className=action_class),
                            html.Span(f" {decision.symbol} ", className="text-muted"),
                            html.Small(f"@${decision.price:.2f}", className="text-muted")
                        ], className="d-flex align-items-center"),
                        html.Small([
                            html.Span(f"Confidence: {confidence_pct} • ", className="text-info"),
                            html.Span(time_str, className="text-muted")
                        ])
                    ], className="border-bottom pb-2 mb-2")
                )
            
            return decisions_html
            
        except Exception as e:
            logger.error(f"Error creating decisions list: {e}")
            return [html.P(f"Error: {str(e)}", className="text-danger")]
    
    def _create_system_status(self, memory_stats: Dict) -> List:
        """Create system status display"""
        try:
            status_items = []
            
            # Memory usage
            memory_pct = memory_stats.get('utilization_percent', 0)
            memory_class = "text-success" if memory_pct < 70 else "text-warning" if memory_pct < 90 else "text-danger"
            
            status_items.append(
                html.Div([
                    html.I(className="fas fa-memory me-2"),
                    html.Span("Memory: "),
                    html.Strong(f"{memory_pct:.1f}%", className=memory_class),
                    html.Small(f" ({memory_stats.get('total_used_mb', 0):.0f}MB / {memory_stats.get('total_limit_mb', 0):.0f}MB)", className="text-muted")
                ], className="mb-2")
            )
            
            # Model status
            models_count = len(memory_stats.get('models', {}))
            status_items.append(
                html.Div([
                    html.I(className="fas fa-brain me-2"),
                    html.Span("Models: "),
                    html.Strong(f"{models_count} active", className="text-info")
                ], className="mb-2")
            )
            
            # Data provider status
            data_health = self.data_provider.health_check()
            streaming_status = "✓ Streaming" if data_health.get('streaming') else "✗ Offline"
            streaming_class = "text-success" if data_health.get('streaming') else "text-danger"
            
            status_items.append(
                html.Div([
                    html.I(className="fas fa-wifi me-2"),
                    html.Span("Data: "),
                    html.Strong(streaming_status, className=streaming_class)
                ], className="mb-2")
            )
            
            # System uptime
            uptime = datetime.now() - self.last_update
            status_items.append(
                html.Div([
                    html.I(className="fas fa-clock me-2"),
                    html.Span("Uptime: "),
                    html.Strong(f"{uptime.seconds//3600:02d}:{(uptime.seconds//60)%60:02d}:{uptime.seconds%60:02d}", className="text-info")
                ], className="mb-2")
            )
            
            return status_items
            
        except Exception as e:
            logger.error(f"Error creating system status: {e}")
            return [html.P(f"Error: {str(e)}", className="text-danger")]
    
    def add_trading_decision(self, decision: TradingDecision):
        """Add a trading decision to the dashboard"""
        self.recent_decisions.append(decision)
        # Keep only last 100 decisions
        if len(self.recent_decisions) > 100:
            self.recent_decisions = self.recent_decisions[-100:]
    
    def _get_real_model_accuracies(self) -> List[float]:
        """
        Get real model accuracy metrics from saved model files or training logs
        Returns empty list if no real metrics are available
        """
        try:
            import json
            from pathlib import Path
            
            # Try to read from model metrics file
            metrics_file = Path("model_metrics.json")
            if metrics_file.exists():
                with open(metrics_file, 'r') as f:
                    metrics = json.load(f)
                if 'accuracies_by_timeframe' in metrics:
                    return metrics['accuracies_by_timeframe']
            
            # Try to parse from training logs
            log_file = Path("logs/training.log") 
            if log_file.exists():
                with open(log_file, 'r') as f:
                    lines = f.readlines()[-200:]  # Recent logs
                
                # Look for accuracy metrics
                accuracies = []
                for line in lines:
                    if 'accuracy:' in line.lower():
                        try:
                            import re
                            acc_match = re.search(r'accuracy[:\s]+([\d\.]+)', line, re.IGNORECASE)
                            if acc_match:
                                accuracy = float(acc_match.group(1))
                                if accuracy <= 1.0:  # Normalize if needed
                                    accuracies.append(accuracy)
                                elif accuracy <= 100:  # Convert percentage
                                    accuracies.append(accuracy / 100.0)
                        except:
                            pass
                
                if accuracies:
                    # Return recent accuracies (up to 4 timeframes)
                    return accuracies[-4:] if len(accuracies) >= 4 else accuracies
            
            # No real metrics found
            return []
            
        except Exception as e:
            logger.error(f"❌ Error retrieving real model accuracies: {e}")
            return []
    
    def run(self, host: str = '127.0.0.1', port: int = 8050, debug: bool = False):
        """Run the dashboard server"""
        try:
            logger.info("="*60)
            logger.info("STARTING TRADING DASHBOARD")
            logger.info(f"ACCESS WEB UI AT: http://{host}:{port}/")
            logger.info("Real-time trading data and charts")
            logger.info("AI model performance monitoring")
            logger.info("Memory usage tracking")
            logger.info("="*60)
            
            # Run the app (updated API for newer Dash versions)
            self.app.run(
                host=host,
                port=port,
                debug=debug,
                use_reloader=False,  # Disable reloader to avoid conflicts
                threaded=True       # Enable threading for better performance
            )
            
        except Exception as e:
            logger.error(f"Error running dashboard: {e}")
            raise

# Convenience function for integration
def create_dashboard(data_provider: DataProvider = None, orchestrator: TradingOrchestrator = None) -> TradingDashboard:
    """Create and return a trading dashboard instance"""
    return TradingDashboard(data_provider, orchestrator)