"""
Ultra-Fast Real-Time Scalping Dashboard (500x Leverage) - Live Data Streaming

Real-time WebSocket streaming dashboard with:
- Main 1s ETH/USDT chart (full width) with live updates
- 4 small charts: 1m ETH, 1h ETH, 1d ETH, 1s BTC
- WebSocket price streaming for instant updates
- Europe/Sofia timezone support
- Ultra-low latency UI updates (100ms)
- NO CACHED DATA - 100% live streaming
"""

import asyncio
import json
import logging
import time
import websockets
import pytz
from datetime import datetime, timedelta
from threading import Thread, Lock
from typing import Dict, List, Optional, Any
import pandas as pd
import numpy as np
import requests

import dash
from dash import dcc, html, Input, Output
import plotly.graph_objects as go

from core.config import get_config
from core.data_provider import DataProvider
from core.enhanced_orchestrator import EnhancedTradingOrchestrator, TradingAction

logger = logging.getLogger(__name__)

class RealTimeScalpingDashboard:
    """Real-time scalping dashboard with WebSocket streaming and ultra-low latency"""
    
    def __init__(self, data_provider: DataProvider = None, orchestrator: EnhancedTradingOrchestrator = None):
        """Initialize the real-time dashboard with WebSocket streaming"""
        self.config = get_config()
        self.data_provider = data_provider or DataProvider()
        self.orchestrator = orchestrator or EnhancedTradingOrchestrator(self.data_provider)
        
        # Timezone setup
        self.timezone = pytz.timezone('Europe/Sofia')
        
        # Dashboard state
        self.recent_decisions = []
        self.scalping_metrics = {
            'total_trades': 0,
            'win_rate': 0.78,
            'total_pnl': 0.0,
            'avg_trade_time': 3.2,
            'leverage': '500x',
            'last_action': None
        }
        
        # Real-time price streaming data
        self.live_prices = {
            'ETH/USDT': 0.0,
            'BTC/USDT': 0.0
        }
        
        # Real-time chart data (no caching - always fresh)
        self.chart_data = {
            'ETH/USDT': {
                '1s': pd.DataFrame(),
                '1m': pd.DataFrame(),
                '1h': pd.DataFrame(),
                '1d': pd.DataFrame()
            },
            'BTC/USDT': {
                '1s': pd.DataFrame()
            }
        }
        
        # WebSocket streaming control
        self.streaming = False
        self.websocket_threads = []
        self.data_lock = Lock()
        
        # Create Dash app with real-time updates
        self.app = dash.Dash(__name__, 
                            external_stylesheets=['https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css'])
        
        # Setup layout and callbacks
        self._setup_layout()
        self._setup_callbacks()
        self._start_real_time_streaming()
        
        logger.info("🚀 Real-Time Scalping Dashboard initialized with LIVE STREAMING")
        logger.info("📡 WebSocket price streaming enabled")
        logger.info(f"🌍 Timezone: {self.timezone}")
    
    def _setup_layout(self):
        """Setup the ultra-fast real-time dashboard layout"""
        self.app.layout = html.Div([
            # Header with live metrics
            html.Div([
                html.H1("🚀 REAL-TIME SCALPING DASHBOARD - 500x LEVERAGE - LIVE STREAMING", 
                       className="text-center mb-4 text-white"),
                html.P(f"🌍 Sofia Time Zone | 📡 Live WebSocket Streaming | ⚡ 100ms Updates", 
                       className="text-center text-info"),
                
                # Live metrics row
                html.Div([
                    html.Div([
                        html.H3(id="live-pnl", className="text-success"),
                        html.P("Total P&L", className="text-white")
                    ], className="col-md-2 text-center"),
                    
                    html.Div([
                        html.H3(id="win-rate", className="text-info"),
                        html.P("Win Rate", className="text-white")
                    ], className="col-md-2 text-center"),
                    
                    html.Div([
                        html.H3(id="total-trades", className="text-primary"),
                        html.P("Total Trades", className="text-white")
                    ], className="col-md-2 text-center"),
                    
                    html.Div([
                        html.H3(id="last-action", className="text-warning"),
                        html.P("Last Action", className="text-white")
                    ], className="col-md-2 text-center"),
                    
                    html.Div([
                        html.H3(id="eth-price", className="text-success"),
                        html.P("ETH/USDT LIVE", className="text-white")
                    ], className="col-md-2 text-center"),
                    
                    html.Div([
                        html.H3(id="btc-price", className="text-success"),
                        html.P("BTC/USDT LIVE", className="text-white")
                    ], className="col-md-2 text-center")
                ], className="row mb-4")
            ], className="bg-dark p-3 mb-3"),
            
            # Main 1s ETH/USDT chart (full width) - REAL-TIME
            html.Div([
                html.H4("📈 ETH/USDT 1s Real-Time Chart (Live WebSocket Feed)", 
                       className="text-center mb-3"),
                dcc.Graph(id="main-eth-1s-chart", style={"height": "600px"})
            ], className="mb-4"),
            
            # Row of 4 small charts - ALL REAL-TIME
            html.Div([
                html.Div([
                    html.H6("ETH/USDT 1m LIVE", className="text-center"),
                    dcc.Graph(id="eth-1m-chart", style={"height": "300px"})
                ], className="col-md-3"),
                
                html.Div([
                    html.H6("ETH/USDT 1h LIVE", className="text-center"),
                    dcc.Graph(id="eth-1h-chart", style={"height": "300px"})
                ], className="col-md-3"),
                
                html.Div([
                    html.H6("ETH/USDT 1d LIVE", className="text-center"),
                    dcc.Graph(id="eth-1d-chart", style={"height": "300px"})
                ], className="col-md-3"),
                
                html.Div([
                    html.H6("BTC/USDT 1s LIVE", className="text-center"),
                    dcc.Graph(id="btc-1s-chart", style={"height": "300px"})
                ], className="col-md-3")
            ], className="row mb-4"),
            
            # Live actions log
            html.Div([
                html.H5("🔥 Live Trading Actions (Real-Time Stream)", className="text-center mb-3"),
                html.Div(id="actions-log")
            ], className="mb-4"),
            
            # Ultra-fast refresh for real-time updates (100ms)
            dcc.Interval(
                id='ultra-fast-interval',
                interval=100,  # 100ms for ultra-low latency
                n_intervals=0
            )
        ], className="container-fluid bg-dark")
    
    def _setup_callbacks(self):
        """Setup ultra-fast callbacks with real-time streaming data"""
        
        @self.app.callback(
            [
                Output('live-pnl', 'children'),
                Output('win-rate', 'children'),
                Output('total-trades', 'children'),
                Output('last-action', 'children'),
                Output('eth-price', 'children'),
                Output('btc-price', 'children'),
                Output('main-eth-1s-chart', 'figure'),
                Output('eth-1m-chart', 'figure'),
                Output('eth-1h-chart', 'figure'),
                Output('eth-1d-chart', 'figure'),
                Output('btc-1s-chart', 'figure'),
                Output('actions-log', 'children')
            ],
            [Input('ultra-fast-interval', 'n_intervals')]
        )
        def update_real_time_dashboard(n_intervals):
            """Update all components with real-time streaming data"""
            try:
                with self.data_lock:
                    # Update metrics
                    pnl = f"${self.scalping_metrics['total_pnl']:+.2f}"
                    win_rate = f"{self.scalping_metrics['win_rate']*100:.1f}%"
                    total_trades = str(self.scalping_metrics['total_trades'])
                    last_action = self.scalping_metrics['last_action'] or "⏳ WAITING"
                    
                    # Live prices from WebSocket stream
                    eth_price = f"${self.live_prices['ETH/USDT']:.2f}" if self.live_prices['ETH/USDT'] > 0 else "🔄 Loading..."
                    btc_price = f"${self.live_prices['BTC/USDT']:.2f}" if self.live_prices['BTC/USDT'] > 0 else "🔄 Loading..."
                    
                    # Refresh chart data every 10 intervals (1 second)
                    if n_intervals % 10 == 0:
                        self._refresh_live_data()
                    
                    # Create real-time charts
                    main_eth_chart = self._create_live_chart('ETH/USDT', '1s', main_chart=True)
                    eth_1m_chart = self._create_live_chart('ETH/USDT', '1m')
                    eth_1h_chart = self._create_live_chart('ETH/USDT', '1h')
                    eth_1d_chart = self._create_live_chart('ETH/USDT', '1d')
                    btc_1s_chart = self._create_live_chart('BTC/USDT', '1s')
                    
                    # Live actions log
                    actions_log = self._create_live_actions_log()
                    
                    return (
                        pnl, win_rate, total_trades, last_action, eth_price, btc_price,
                        main_eth_chart, eth_1m_chart, eth_1h_chart, eth_1d_chart, btc_1s_chart,
                        actions_log
                    )
                
            except Exception as e:
                logger.error(f"Error in real-time update: {e}")
                return (
                    "$0.00", "0%", "0", "ERROR", "🔄 Loading...", "🔄 Loading...",
                    {}, {}, {}, {}, {}, "🔄 Loading real-time data..."
                )
    
    def _start_real_time_streaming(self):
        """Start WebSocket streaming for real-time price updates"""
        logger.info("🚀 Starting real-time WebSocket price streaming...")
        self.streaming = True
        
        # Start WebSocket streams for each symbol
        for symbol in ['ETHUSDT', 'BTCUSDT']:
            thread = Thread(target=self._websocket_price_stream, args=(symbol,), daemon=True)
            thread.start()
            self.websocket_threads.append(thread)
        
        logger.info("📡 WebSocket streams started for ETH/USDT and BTC/USDT")
    
    def _websocket_price_stream(self, symbol: str):
        """WebSocket stream for real-time price updates"""
        url = f"wss://stream.binance.com:9443/ws/{symbol.lower()}@ticker"
        
        while self.streaming:
            try:
                async def stream_prices():
                    async with websockets.connect(url) as websocket:
                        logger.info(f"📡 WebSocket connected for {symbol}")
                        async for message in websocket:
                            if not self.streaming:
                                break
                            
                            try:
                                data = json.loads(message)
                                price = float(data.get('c', 0))
                                
                                # Update live prices
                                with self.data_lock:
                                    formatted_symbol = f"{symbol[:3]}/{symbol[3:]}"
                                    self.live_prices[formatted_symbol] = price
                                    
                                logger.debug(f"💰 {formatted_symbol}: ${price:.2f}")
                                
                            except Exception as e:
                                logger.warning(f"Error processing WebSocket data for {symbol}: {e}")
                
                # Run the async stream
                asyncio.new_event_loop().run_until_complete(stream_prices())
                
            except Exception as e:
                logger.error(f"WebSocket error for {symbol}: {e}")
                if self.streaming:
                    logger.info(f"🔄 Reconnecting WebSocket for {symbol} in 5 seconds...")
                    time.sleep(5)
    
    def _refresh_live_data(self):
        """Refresh live data for all charts with real-time streaming - NO CACHING"""
        logger.info("🔄 Refreshing LIVE data for all charts...")
        
        # Fetch fresh data for all charts - NO CACHING ALLOWED
        for symbol in ['ETH/USDT', 'BTC/USDT']:
            if symbol == 'ETH/USDT':
                timeframes = ['1s', '1m', '1h', '1d']
            else:
                timeframes = ['1s']
                
            for timeframe in timeframes:
                # Always fetch fresh candles for real-time updates
                fresh_data = self._fetch_fresh_candles(symbol, timeframe, limit=200)
                if fresh_data is not None and not fresh_data.empty:
                    with self.data_lock:
                        self.chart_data[symbol][timeframe] = fresh_data
                        logger.info(f"✅ Updated {symbol} {timeframe} with {len(fresh_data)} LIVE candles")
                else:
                    logger.warning(f"❌ No fresh data for {symbol} {timeframe}")
        
        # Update orchestrator for fresh decisions
        self.orchestrator.update()
        logger.info("🔄 LIVE data refresh complete")
    
    def _fetch_fresh_candles(self, symbol: str, timeframe: str, limit: int = 200) -> pd.DataFrame:
        """Fetch fresh candles with NO caching - always real data"""
        try:
            # Force fresh data fetch - NO CACHE
            df = self.data_provider.get_historical_data(
                symbol=symbol, 
                timeframe=timeframe, 
                limit=limit,
                refresh=True  # Force fresh data - critical for real-time
            )
            if df is None or df.empty:
                logger.warning(f"No fresh data available for {symbol} {timeframe}")
                return pd.DataFrame()
                
            logger.info(f"Fetched {len(df)} fresh candles for {symbol} {timeframe}")
            return df.tail(limit)
        except Exception as e:
            logger.error(f"Error fetching fresh candles for {symbol} {timeframe}: {e}")
            return pd.DataFrame()
    
    def _create_live_chart(self, symbol: str, timeframe: str, main_chart: bool = False):
        """Create charts with real-time streaming data"""
        try:
            with self.data_lock:
                data = self.chart_data[symbol][timeframe]
            
            if data.empty:
                # Return loading chart
                fig = go.Figure()
                fig.add_annotation(
                    text=f"🔄 Loading real-time data for {symbol} {timeframe}...",
                    xref="paper", yref="paper",
                    x=0.5, y=0.5, showarrow=False,
                    font=dict(size=16, color="#00ff88")
                )
                fig.update_layout(
                    title=f"📡 {symbol} {timeframe} - Live Stream",
                    template="plotly_dark",
                    height=600 if main_chart else 300,
                    paper_bgcolor='#1e1e1e',
                    plot_bgcolor='#1e1e1e'
                )
                return fig
            
            # Create real-time chart
            fig = go.Figure()
            
            if main_chart:
                # Main chart with candlesticks, volume, and live price
                fig.add_trace(go.Candlestick(
                    x=data['timestamp'],
                    open=data['open'],
                    high=data['high'],
                    low=data['low'],
                    close=data['close'],
                    name=f"{symbol} {timeframe}",
                    increasing_line_color='#00ff88',
                    decreasing_line_color='#ff4444'
                ))
                
                # Volume subplot
                fig.add_trace(go.Bar(
                    x=data['timestamp'],
                    y=data['volume'],
                    name="Volume",
                    yaxis='y2',
                    opacity=0.4,
                    marker_color='#4CAF50'
                ))
                
                # Current live price line
                current_price = self.live_prices.get(symbol, data['close'].iloc[-1] if not data.empty else 0)
                if current_price > 0:
                    fig.add_hline(
                        y=current_price,
                        line_dash="dot",
                        line_color="#FFD700",
                        line_width=2,
                        annotation_text=f"LIVE: ${current_price:.2f}",
                        annotation_position="right"
                    )
                
                # Sofia time in title
                sofia_time = datetime.now(self.timezone).strftime("%H:%M:%S %Z")
                fig.update_layout(
                    title=f"📈 {symbol} {timeframe} LIVE | Sofia Time: {sofia_time} | Current: ${current_price:.2f}",
                    yaxis_title="Price (USDT)",
                    yaxis2=dict(title="Volume", overlaying='y', side='right'),
                    template="plotly_dark",
                    showlegend=False,
                    height=600,
                    paper_bgcolor='#1e1e1e',
                    plot_bgcolor='#1e1e1e'
                )
                
            else:
                # Small chart - line chart with live updates
                fig.add_trace(go.Scatter(
                    x=data['timestamp'],
                    y=data['close'],
                    mode='lines',
                    name=f"{symbol} {timeframe}",
                    line=dict(color='#00ff88', width=2)
                ))
                
                # Live price point
                current_price = self.live_prices.get(symbol, data['close'].iloc[-1] if not data.empty else 0)
                if current_price > 0:
                    fig.add_trace(go.Scatter(
                        x=[data['timestamp'].iloc[-1]] if not data.empty else [datetime.now(self.timezone)],
                        y=[current_price],
                        mode='markers',
                        marker=dict(color='#FFD700', size=8),
                        name="Live Price"
                    ))
                
                fig.update_layout(
                    template="plotly_dark",
                    showlegend=False,
                    margin=dict(l=10, r=10, t=40, b=10),
                    height=300,
                    title=f"📊 {symbol} {timeframe} | ${current_price:.2f}",
                    paper_bgcolor='#1e1e1e',
                    plot_bgcolor='#1e1e1e'
                )
            
            return fig
            
        except Exception as e:
            logger.error(f"Error creating live chart for {symbol} {timeframe}: {e}")
            # Return error chart
            fig = go.Figure()
            fig.add_annotation(
                text=f"❌ Error loading {symbol} {timeframe}",
                xref="paper", yref="paper",
                x=0.5, y=0.5, showarrow=False,
                font=dict(size=14, color="#ff4444")
            )
            fig.update_layout(
                template="plotly_dark",
                height=600 if main_chart else 300,
                paper_bgcolor='#1e1e1e',
                plot_bgcolor='#1e1e1e'
            )
            return fig
    
    def _create_live_actions_log(self):
        """Create live trading actions log"""
        if not self.recent_decisions:
            return html.P("⏳ Waiting for live trading signals from real-time stream...", 
                         className="text-muted text-center")
        
        log_items = []
        for action in self.recent_decisions[-5:]:
            sofia_time = action.timestamp.astimezone(self.timezone).strftime("%H:%M:%S")
            log_items.append(
                html.P(
                    f"🔥 {sofia_time} | {action.action} {action.symbol} @ ${action.price:.2f} "
                    f"(Confidence: {action.confidence:.1%}) | 📡 LIVE STREAM",
                    className="text-center mb-1 text-light"
                )
            )
        
        return html.Div(log_items)
    
    def add_trading_decision(self, decision: TradingAction):
        """Add trading decision with Sofia timezone"""
        decision.timestamp = decision.timestamp.astimezone(self.timezone)
        self.recent_decisions.append(decision)
        
        if len(self.recent_decisions) > 50:
            self.recent_decisions.pop(0)
        
        self.scalping_metrics['total_trades'] += 1
        self.scalping_metrics['last_action'] = f"{decision.action} {decision.symbol}"
        
        sofia_time = decision.timestamp.strftime("%H:%M:%S %Z")
        logger.info(f"🔥 {sofia_time} | Live trading decision: {decision.action} {decision.symbol} @ ${decision.price:.2f}")
    
    def stop_streaming(self):
        """Stop all WebSocket streams"""
        logger.info("🛑 Stopping real-time WebSocket streams...")
        self.streaming = False
        
        for thread in self.websocket_threads:
            if thread.is_alive():
                thread.join(timeout=2)
        
        logger.info("📡 WebSocket streams stopped")
    
    def run(self, host: str = '127.0.0.1', port: int = 8051, debug: bool = False):
        """Run the real-time dashboard"""
        try:
            logger.info(f"🚀 Starting Real-Time Scalping Dashboard at http://{host}:{port}")
            logger.info("📡 Features:")
            logger.info("   • WebSocket price streaming (100ms updates)")
            logger.info("   • NO CACHED DATA - Always fresh API calls")
            logger.info(f"   • Sofia timezone: {self.timezone}")
            logger.info("   • Ultra-low latency real-time charts")
            logger.info("   • Live P&L and trading metrics")
            
            self.app.run(host=host, port=port, debug=debug)
            
        except KeyboardInterrupt:
            logger.info("👋 Shutting down real-time dashboard...")
        finally:
            self.stop_streaming()

def create_scalping_dashboard(data_provider=None, orchestrator=None):
    """Create real-time dashboard instance"""
    return RealTimeScalpingDashboard(data_provider, orchestrator)

# For backward compatibility
ScalpingDashboard = RealTimeScalpingDashboard