//+------------------------------------------------------------------+
//| RevolutionaryDashboard.mqh - AI-Powered Intelligent Dashboard   |
//| Next-Generation Trading Intelligence Display                    |
//+------------------------------------------------------------------+

#ifndef REVOLUTIONARY_DASHBOARD_MQH
#define REVOLUTIONARY_DASHBOARD_MQH

#include <AI/AIIntegrationManager.mqh>
#include <Indicators/IndicatorEngine.mqh>
#include <Trade/RiskManager.mqh>
#include <Trade/TradeManager.mqh>

// Intelligence levels
enum ENUM_CONVICTION_LEVEL
{
    CONVICTION_WEAK = 1,
    CONVICTION_MODERATE = 2,
    CONVICTION_STRONG = 3,
    CONVICTION_VERY_STRONG = 4
};

// Market edge strength
enum ENUM_EDGE_STRENGTH
{
    EDGE_NONE = 0,
    EDGE_WEAK = 1,
    EDGE_MODERATE = 2,
    EDGE_STRONG = 3,
    EDGE_VERY_STRONG = 4
};

// Smart trading intelligence
struct TradingIntelligence
{
    ENUM_TRADE_SIGNAL signal;
    ENUM_CONVICTION_LEVEL conviction;
    string reason;                    // Natural language explanation
    double risk_reward_ratio;
    double probability_success;       // Calculated probability
    double optimal_position_size;
    string key_level;                // Important S/R level
    string market_narrative;         // What's happening in market
};

// Multi-timeframe analysis
struct MultiTimeframeIntelligence
{
    bool trend_alignment;            // All timeframes aligned?
    int bullish_timeframes;          // How many TFs are bullish
    int bearish_timeframes;          // How many TFs are bearish
    string trend_strength;           // Weak/Moderate/Strong/Very Strong
    string momentum_state;           // Accelerating/Decelerating/Stalled
    ENUM_EDGE_STRENGTH edge_strength;
};

// Market edge structure (for compatibility with main EA)
struct MarketEdge
{
    ENUM_EDGE_STRENGTH strength;
    double confidence;
    string reason;
    bool trend_alignment;
    int supporting_timeframes;
};

// Risk scenario analysis
struct RiskScenarios
{
    double best_case_pnl;           // Best case profit
    double base_case_pnl;           // Expected profit
    double worst_case_pnl;          // Worst case loss
    double max_account_risk;        // Maximum account risk %
    string risk_assessment;         // Risk level description
    string exit_strategy;           // When to exit
};

// Risk scenario (singular for EA compatibility)
struct RiskScenario
{
    double best_case_profit;        // Best case profit %
    double base_case_profit;        // Expected profit %
    double base_case_loss;          // Expected loss %
    double worst_case_loss;         // Worst case loss %
    double max_account_risk;        // Maximum account risk %
    string risk_level;              // Risk assessment
    string exit_strategy;           // Exit plan
};

// Performance intelligence
struct PerformanceIntelligence
{
    double daily_pnl_pct;
    double daily_pnl_dollar;
    double recent_win_rate;         // Last 20 trades
    double avg_risk_reward;
    string best_strategy;           // What's working best
    string performance_trend;       // Improving/Declining/Stable
};

class RevolutionaryDashboard
{
private:
    string m_symbol;
    string m_prefix;
    int m_x_pos;
    int m_y_pos;
    int m_width;
    int m_height;
    
    // Intelligence components
    CAdvancedIndicatorEngine* m_indicator_engine;
    CAdvancedRiskManager* m_risk_manager;
    CAdvancedTradeManager* m_trade_manager;
    AIIntegrationManager* m_ai_manager;
    
    // Intelligence cache
    TradingIntelligence m_trading_intel;
    MultiTimeframeIntelligence m_mtf_intel;
    RiskScenarios m_risk_scenarios;
    PerformanceIntelligence m_performance_intel;
    
    // Display state
    bool m_initialized;
    datetime m_last_update;
    datetime m_last_intelligence_update;
    
public:
    RevolutionaryDashboard(void);
    ~RevolutionaryDashboard(void);
    
    // Core methods
    bool Initialize(string symbol, CAdvancedIndicatorEngine* indicator_engine, 
                   CAdvancedRiskManager* risk_manager, CAdvancedTradeManager* trade_manager,
                   AIIntegrationManager* ai_manager, int x_pos = 20, int y_pos = 50);
    void UpdateLive(void);
    void UpdateIntelligence(void);
    void Destroy(void);
    
    // Getter methods for intelligence data
    TradingIntelligence GetTradingIntelligence(void) { return m_trading_intel; }
    MarketEdge GetMarketEdge(void);
    RiskScenarios GetRiskScenarios(void) { return m_risk_scenarios; }
    RiskScenario GetRiskScenario(void);         // Singular version for EA compatibility
    
private:
    // Intelligence engines
    void CalculateTradingIntelligence(void);
    void CalculateMultiTimeframeIntelligence(void);
    void CalculateRiskScenarios(void);
    void CalculatePerformanceIntelligence(void);
    
    // Natural language generation
    string GenerateMarketNarrative(AIAnalysisResult &ai_result, IndicatorSignal &tech_signal);
    string GenerateTradeReason(IndicatorSignal &signal, MultiTimeframeIntelligence &mtf);
    string GenerateRiskAssessment(double max_risk);
    string GeneratePerformanceTrend(double win_rate, double recent_pnl);
    
    // Probability calculations
    double CalculateSuccessProbability(IndicatorSignal &tech_signal, MultiTimeframeIntelligence &mtf);
    ENUM_CONVICTION_LEVEL CalculateConviction(double probability, ENUM_EDGE_STRENGTH edge);
    ENUM_EDGE_STRENGTH CalculateMarketEdge(IndicatorSignal &tech_signal, MultiTimeframeIntelligence &mtf);
    
    // Dashboard creation
    void CreateBackground(void);
    void CreateHeader(void);
    void CreateTradingIntelligenceSection(void);
    void CreateMultiTimeframeSection(void);
    void CreateRiskScenariosSection(void);
    void CreatePerformanceSection(void);
    void CreateSystemStatusSection(void);
    
    // Update methods
    void UpdateTradingIntelligenceDisplay(void);
    void UpdateMultiTimeframeDisplay(void);
    void UpdateRiskScenariosDisplay(void);
    void UpdatePerformanceDisplay(void);
    void UpdateSystemStatusDisplay(void);
    
    // Utility methods
    void CreateLabel(string name, string text, int x, int y, color clr = clrWhite, int size = 8);
    void CreateRectangle(string name, int x, int y, int width, int height, color bg_color);
    color GetConvictionColor(ENUM_CONVICTION_LEVEL conviction);
    color GetEdgeColor(ENUM_EDGE_STRENGTH edge);
    string ConvictionToString(ENUM_CONVICTION_LEVEL conviction);
    string EdgeToString(ENUM_EDGE_STRENGTH edge);
    void CleanupObjects(void);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
RevolutionaryDashboard::RevolutionaryDashboard(void)
{
    m_symbol = "";
    m_prefix = "RevAI_Intel_";
    m_x_pos = 20;
    m_y_pos = 50;
    m_width = 420;
    m_height = 600;
    m_initialized = false;
    m_last_update = 0;
    m_last_intelligence_update = 0;
    
    m_indicator_engine = NULL;
    m_risk_manager = NULL;
    m_trade_manager = NULL;
    m_ai_manager = NULL;
    
    // Initialize intelligence structures
    ZeroMemory(m_trading_intel);
    ZeroMemory(m_mtf_intel);
    ZeroMemory(m_risk_scenarios);
    ZeroMemory(m_performance_intel);
}

//+------------------------------------------------------------------+
//| Destructor                                                      |
//+------------------------------------------------------------------+
RevolutionaryDashboard::~RevolutionaryDashboard(void)
{
    Destroy();
}

//+------------------------------------------------------------------+
//| Initialize revolutionary dashboard                               |
//+------------------------------------------------------------------+
bool RevolutionaryDashboard::Initialize(string symbol, CAdvancedIndicatorEngine* indicator_engine, 
                                       CAdvancedRiskManager* risk_manager, CAdvancedTradeManager* trade_manager,
                                       AIIntegrationManager* ai_manager, int x_pos = 20, int y_pos = 50)
{
    m_symbol = symbol;
    m_x_pos = x_pos;
    m_y_pos = y_pos;
    m_prefix = "RevAI_" + m_symbol + "_";
    
    // Store component references
    m_indicator_engine = indicator_engine;
    m_risk_manager = risk_manager;
    m_trade_manager = trade_manager;
    m_ai_manager = ai_manager;
    
    // Create dashboard sections
    CreateBackground();
    CreateHeader();
    CreateTradingIntelligenceSection();
    CreateMultiTimeframeSection();
    CreateRiskScenariosSection();
    CreatePerformanceSection();
    CreateSystemStatusSection();
    
    // Initial intelligence calculation
    UpdateIntelligence();
    
    m_initialized = true;
    ChartRedraw();
    
    Print("🚀 Revolutionary Intelligence Dashboard initialized for ", m_symbol);
    return true;
}

//+------------------------------------------------------------------+
//| Update live data (called frequently)                            |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateLive(void)
{
    if (!m_initialized) return;
    
    datetime current_time = TimeCurrent();
    
    // Update intelligence every 30 seconds
    if (current_time - m_last_intelligence_update >= 30)
    {
        UpdateIntelligence();
        m_last_intelligence_update = current_time;
    }
    
    // Update display every 5 seconds
    if (current_time - m_last_update >= 5)
    {
        UpdateTradingIntelligenceDisplay();
        UpdateMultiTimeframeDisplay();
        UpdateRiskScenariosDisplay();
        UpdatePerformanceDisplay();
        UpdateSystemStatusDisplay();
        
        m_last_update = current_time;
        ChartRedraw();
    }
}

//+------------------------------------------------------------------+
//| Update all intelligence calculations                             |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateIntelligence(void)
{
    if (m_indicator_engine == NULL || m_risk_manager == NULL || 
        m_trade_manager == NULL || m_ai_manager == NULL) return;
    
    CalculateTradingIntelligence();
    CalculateMultiTimeframeIntelligence();
    CalculateRiskScenarios();
    CalculatePerformanceIntelligence();
}

//+------------------------------------------------------------------+
//| Calculate trading intelligence                                   |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CalculateTradingIntelligence(void)
{
    // Get current signals
    IndicatorSignal tech_signal = m_indicator_engine->GetSignal();
    MarketStructure market_structure = m_indicator_engine->GetMarketStructure();
    
    // Calculate multi-timeframe intelligence first
    CalculateMultiTimeframeIntelligence();
    
    // Set basic signal
    m_trading_intel.signal = tech_signal.signal;
    
    // Calculate success probability
    m_trading_intel.probability_success = CalculateSuccessProbability(tech_signal, m_mtf_intel);
    
    // Calculate market edge and conviction
    ENUM_EDGE_STRENGTH edge = CalculateMarketEdge(tech_signal, m_mtf_intel);
    m_trading_intel.conviction = CalculateConviction(m_trading_intel.probability_success, edge);
    
    // Calculate risk/reward ratio
    double current_price = SymbolInfoDouble(m_symbol, SYMBOL_BID);
    if (m_trading_intel.signal == SIGNAL_BUY)
    {
        double stop_loss = market_structure.support;
        double take_profit = market_structure.resistance;
        if (stop_loss > 0 && take_profit > 0)
        {
            double risk = current_price - stop_loss;
            double reward = take_profit - current_price;
            m_trading_intel.risk_reward_ratio = (risk > 0) ? reward / risk : 0;
        }
    }
    else if (m_trading_intel.signal == SIGNAL_SELL)
    {
        double stop_loss = market_structure.resistance;
        double take_profit = market_structure.support;
        if (stop_loss > 0 && take_profit > 0)
        {
            double risk = stop_loss - current_price;
            double reward = current_price - take_profit;
            m_trading_intel.risk_reward_ratio = (risk > 0) ? reward / risk : 0;
        }
    }
    
    // Generate natural language explanation
    m_trading_intel.reason = GenerateTradeReason(tech_signal, m_mtf_intel);
    
    // Set key level
    if (m_trading_intel.signal == SIGNAL_BUY)
        m_trading_intel.key_level = "Support: " + DoubleToString(market_structure.support, _Digits);
    else if (m_trading_intel.signal == SIGNAL_SELL)
        m_trading_intel.key_level = "Resistance: " + DoubleToString(market_structure.resistance, _Digits);
    else
        m_trading_intel.key_level = "Range: " + DoubleToString(market_structure.support, _Digits) + 
                                   " - " + DoubleToString(market_structure.resistance, _Digits);
    
    // Calculate optimal position size (Kelly criterion)
    if (m_trading_intel.risk_reward_ratio > 0 && m_trading_intel.probability_success > 0.5)
    {
        double win_rate = m_trading_intel.probability_success;
        double avg_win = m_trading_intel.risk_reward_ratio;
        double avg_loss = 1.0;
        double kelly_pct = (win_rate * avg_win - (1 - win_rate) * avg_loss) / avg_win;
        m_trading_intel.optimal_position_size = MathMax(0, MathMin(kelly_pct * 100, 5.0)); // Cap at 5%
    }
    else
    {
        m_trading_intel.optimal_position_size = 0;
    }
}

//+------------------------------------------------------------------+
//| Calculate multi-timeframe intelligence                          |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CalculateMultiTimeframeIntelligence(void)
{
    // Analyze multiple timeframes
    ENUM_TIMEFRAMES timeframes[] = {PERIOD_M5, PERIOD_M15, PERIOD_H1, PERIOD_H4, PERIOD_D1};
    int bullish_count = 0;
    int bearish_count = 0;
    
    for (int i = 0; i < ArraySize(timeframes); i++)
    {
        ENUM_TREND_STATE trend = m_indicator_engine->GetTrend(timeframes[i]);
        if (trend == TREND_BULLISH) bullish_count++;
        else if (trend == TREND_BEARISH) bearish_count++;
    }
    
    m_mtf_intel.bullish_timeframes = bullish_count;
    m_mtf_intel.bearish_timeframes = bearish_count;
    m_mtf_intel.trend_alignment = (bullish_count >= 4 || bearish_count >= 4);
    
    // Determine trend strength
    int max_aligned = MathMax(bullish_count, bearish_count);
    if (max_aligned >= 5) m_mtf_intel.trend_strength = "Very Strong";
    else if (max_aligned >= 4) m_mtf_intel.trend_strength = "Strong";
    else if (max_aligned >= 3) m_mtf_intel.trend_strength = "Moderate";
    else m_mtf_intel.trend_strength = "Weak";
    
    // Analyze momentum
    double trend_strength = m_indicator_engine->GetTrendStrength();
    if (trend_strength > 0.8) m_mtf_intel.momentum_state = "Accelerating";
    else if (trend_strength > 0.5) m_mtf_intel.momentum_state = "Steady";
    else if (trend_strength > 0.2) m_mtf_intel.momentum_state = "Decelerating";
    else m_mtf_intel.momentum_state = "Stalled";
    
    // Calculate edge strength
    m_mtf_intel.edge_strength = CalculateMarketEdge(m_indicator_engine->GetSignal(), m_mtf_intel);
}

//+------------------------------------------------------------------+
//| Calculate market edge strength                                  |
//+------------------------------------------------------------------+
ENUM_EDGE_STRENGTH RevolutionaryDashboard::CalculateMarketEdge(IndicatorSignal &tech_signal, MultiTimeframeIntelligence &mtf)
{
    int edge_score = 0;
    
    // Technical signal strength
    if (tech_signal.strength >= SIGNAL_VERY_STRONG) edge_score += 3;
    else if (tech_signal.strength >= SIGNAL_STRONG) edge_score += 2;
    else if (tech_signal.strength >= SIGNAL_MODERATE) edge_score += 1;
    
    // Multi-timeframe alignment
    if (mtf.trend_alignment) edge_score += 3;
    else if (MathMax(mtf.bullish_timeframes, mtf.bearish_timeframes) >= 3) edge_score += 2;
    else if (MathMax(mtf.bullish_timeframes, mtf.bearish_timeframes) >= 2) edge_score += 1;
    
    // Momentum state
    if (mtf.momentum_state == "Accelerating") edge_score += 2;
    else if (mtf.momentum_state == "Steady") edge_score += 1;
    
    // Technical confidence
    if (tech_signal.confidence >= 0.8) edge_score += 2;
    else if (tech_signal.confidence >= 0.6) edge_score += 1;
    
    // Convert score to edge strength
    if (edge_score >= 8) return EDGE_VERY_STRONG;
    else if (edge_score >= 6) return EDGE_STRONG;
    else if (edge_score >= 4) return EDGE_MODERATE;
    else if (edge_score >= 2) return EDGE_WEAK;
    else return EDGE_NONE;
}

//+------------------------------------------------------------------+
//| Calculate success probability                                    |
//+------------------------------------------------------------------+
double RevolutionaryDashboard::CalculateSuccessProbability(IndicatorSignal &tech_signal, MultiTimeframeIntelligence &mtf)
{
    double base_probability = 0.5; // Start with 50%
    
    // Adjust for technical signal strength
    if (tech_signal.strength >= SIGNAL_VERY_STRONG) base_probability += 0.25;
    else if (tech_signal.strength >= SIGNAL_STRONG) base_probability += 0.15;
    else if (tech_signal.strength >= SIGNAL_MODERATE) base_probability += 0.10;
    
    // Adjust for multi-timeframe alignment
    if (mtf.trend_alignment) base_probability += 0.20;
    else if (MathMax(mtf.bullish_timeframes, mtf.bearish_timeframes) >= 3) base_probability += 0.10;
    
    // Adjust for momentum
    if (mtf.momentum_state == "Accelerating") base_probability += 0.10;
    else if (mtf.momentum_state == "Decelerating") base_probability -= 0.10;
    
    // Adjust for technical confidence
    base_probability += (tech_signal.confidence - 0.5) * 0.3;
    
    return MathMax(0.1, MathMin(0.95, base_probability));
}

//+------------------------------------------------------------------+
//| Calculate conviction level                                       |
//+------------------------------------------------------------------+
ENUM_CONVICTION_LEVEL RevolutionaryDashboard::CalculateConviction(double probability, ENUM_EDGE_STRENGTH edge)
{
    double conviction_score = probability;
    
    // Adjust for edge strength
    if (edge >= EDGE_VERY_STRONG) conviction_score += 0.2;
    else if (edge >= EDGE_STRONG) conviction_score += 0.15;
    else if (edge >= EDGE_MODERATE) conviction_score += 0.10;
    else if (edge >= EDGE_WEAK) conviction_score += 0.05;
    
    conviction_score = MathMin(1.0, conviction_score);
    
    if (conviction_score >= 0.85) return CONVICTION_VERY_STRONG;
    else if (conviction_score >= 0.75) return CONVICTION_STRONG;
    else if (conviction_score >= 0.65) return CONVICTION_MODERATE;
    else return CONVICTION_WEAK;
}

//+------------------------------------------------------------------+
//| Generate natural language trade reason                          |
//+------------------------------------------------------------------+
string RevolutionaryDashboard::GenerateTradeReason(IndicatorSignal &signal, MultiTimeframeIntelligence &mtf)
{
    string reason = "";
    
    if (signal.signal == SIGNAL_BUY)
    {
        reason = "BULLISH: ";
        if (mtf.trend_alignment) reason += "All timeframes aligned bullish. ";
        else if (mtf.bullish_timeframes >= 3) reason += IntegerToString(mtf.bullish_timeframes) + "/5 timeframes bullish. ";
        
        if (mtf.momentum_state == "Accelerating") reason += "Momentum accelerating. ";
        else if (mtf.momentum_state == "Steady") reason += "Steady upward momentum. ";
        
        if (signal.strength >= SIGNAL_STRONG) reason += "Strong technical confirmation.";
        else reason += "Moderate technical setup.";
    }
    else if (signal.signal == SIGNAL_SELL)
    {
        reason = "BEARISH: ";
        if (mtf.trend_alignment) reason += "All timeframes aligned bearish. ";
        else if (mtf.bearish_timeframes >= 3) reason += IntegerToString(mtf.bearish_timeframes) + "/5 timeframes bearish. ";
        
        if (mtf.momentum_state == "Accelerating") reason += "Momentum accelerating down. ";
        else if (mtf.momentum_state == "Steady") reason += "Steady downward momentum. ";
        
        if (signal.strength >= SIGNAL_STRONG) reason += "Strong technical confirmation.";
        else reason += "Moderate technical setup.";
    }
    else
    {
        reason = "NEUTRAL: Mixed signals across timeframes. ";
        if (mtf.bullish_timeframes == mtf.bearish_timeframes) reason += "Equal bullish/bearish timeframes. ";
        reason += "Waiting for clearer direction.";
    }
    
    return reason;
}

//+------------------------------------------------------------------+
//| Calculate risk scenarios                                         |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CalculateRiskScenarios(void)
{
    if (m_trading_intel.risk_reward_ratio <= 0)
    {
        m_risk_scenarios.best_case_pnl = 0;
        m_risk_scenarios.base_case_pnl = 0;
        m_risk_scenarios.worst_case_pnl = 0;
        m_risk_scenarios.max_account_risk = 0;
        m_risk_scenarios.risk_assessment = "No active setup";
        m_risk_scenarios.exit_strategy = "Wait for better opportunity";
        return;
    }
    
    double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double position_size_pct = MathMin(m_trading_intel.optimal_position_size, 2.0); // Conservative cap
    double risk_amount = account_balance * (position_size_pct / 100.0);
    
    // Calculate scenarios
    m_risk_scenarios.worst_case_pnl = -risk_amount; // Stop loss hit
    m_risk_scenarios.base_case_pnl = risk_amount * (m_trading_intel.risk_reward_ratio * 0.7); // Partial profit
    m_risk_scenarios.best_case_pnl = risk_amount * m_trading_intel.risk_reward_ratio; // Full target
    
    m_risk_scenarios.max_account_risk = position_size_pct;
    
    // Generate risk assessment
    if (position_size_pct <= 1.0) m_risk_scenarios.risk_assessment = "Conservative";
    else if (position_size_pct <= 2.0) m_risk_scenarios.risk_assessment = "Moderate";
    else m_risk_scenarios.risk_assessment = "Aggressive";
    
    // Generate exit strategy
    if (m_trading_intel.conviction >= CONVICTION_STRONG)
        m_risk_scenarios.exit_strategy = "Hold for full target";
    else if (m_trading_intel.conviction >= CONVICTION_MODERATE)
        m_risk_scenarios.exit_strategy = "Take partial at 1:1.5 R:R";
    else
        m_risk_scenarios.exit_strategy = "Quick exit on weakness";
}

//+------------------------------------------------------------------+
//| Calculate performance intelligence                               |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CalculatePerformanceIntelligence(void)
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    static double daily_start_balance = current_balance;
    static int last_day = -1;
    
    // Reset on new day
    int current_day = TimeDay(TimeCurrent());
    if (last_day != -1 && current_day != last_day)
    {
        daily_start_balance = current_balance;
    }
    last_day = current_day;
    
    // Calculate daily P&L
    m_performance_intel.daily_pnl_dollar = current_balance - daily_start_balance;
    m_performance_intel.daily_pnl_pct = (daily_start_balance > 0) ? 
        (m_performance_intel.daily_pnl_dollar / daily_start_balance) * 100 : 0;
    
    // Simulate recent performance (in real implementation, track actual trades)
    m_performance_intel.recent_win_rate = 0.68; // 68% win rate
    m_performance_intel.avg_risk_reward = 1.8;
    m_performance_intel.best_strategy = "Trend Following";
    
    // Determine performance trend
    if (m_performance_intel.daily_pnl_pct > 2.0) 
        m_performance_intel.performance_trend = "Excellent";
    else if (m_performance_intel.daily_pnl_pct > 0.5) 
        m_performance_intel.performance_trend = "Good";
    else if (m_performance_intel.daily_pnl_pct > -0.5) 
        m_performance_intel.performance_trend = "Stable";
    else 
        m_performance_intel.performance_trend = "Declining";
}

//+------------------------------------------------------------------+
//| Create dashboard background                                      |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateBackground(void)
{
    // Main background
    CreateRectangle(m_prefix + "background", m_x_pos, m_y_pos, m_width, m_height, C'15,15,25');
    
    // Header background
    CreateRectangle(m_prefix + "header_bg", m_x_pos, m_y_pos, m_width, 45, C'65,105,225');
    
    // Section backgrounds
    CreateRectangle(m_prefix + "intel_bg", m_x_pos + 5, m_y_pos + 55, m_width - 10, 120, C'25,30,40');
    CreateRectangle(m_prefix + "mtf_bg", m_x_pos + 5, m_y_pos + 185, m_width - 10, 100, C'25,30,40');
    CreateRectangle(m_prefix + "risk_bg", m_x_pos + 5, m_y_pos + 295, m_width - 10, 100, C'25,30,40');
    CreateRectangle(m_prefix + "perf_bg", m_x_pos + 5, m_y_pos + 405, m_width - 10, 100, C'25,30,40');
    CreateRectangle(m_prefix + "status_bg", m_x_pos + 5, m_y_pos + 515, m_width - 10, 75, C'25,30,40');
}

//+------------------------------------------------------------------+
//| Create dashboard header                                          |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateHeader(void)
{
    CreateLabel(m_prefix + "title", "🚀 Revolutionary AI Intelligence", m_x_pos + 10, m_y_pos + 8, clrWhite, 12);
    CreateLabel(m_prefix + "symbol", m_symbol, m_x_pos + m_width - 80, m_y_pos + 8, clrGold, 12);
    CreateLabel(m_prefix + "status", "● INTELLIGENT ANALYSIS ACTIVE", m_x_pos + 10, m_y_pos + 25, clrLimeGreen, 9);
}

//+------------------------------------------------------------------+
//| Create trading intelligence section                              |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateTradingIntelligenceSection(void)
{
    int y_start = m_y_pos + 60;
    
    CreateLabel(m_prefix + "intel_header", "═══ TRADING INTELLIGENCE ═══", m_x_pos + 10, y_start, clrCyan, 10);
    CreateLabel(m_prefix + "signal", "Signal: ANALYZING...", m_x_pos + 10, y_start + 20, clrWhite, 9);
    CreateLabel(m_prefix + "conviction", "Conviction: --", m_x_pos + 220, y_start + 20, clrWhite, 9);
    CreateLabel(m_prefix + "probability", "Success Probability: --%", m_x_pos + 10, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "risk_reward", "Risk:Reward = --", m_x_pos + 220, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "position_size", "Optimal Size: --%", m_x_pos + 10, y_start + 50, clrWhite, 8);
    CreateLabel(m_prefix + "key_level", "Key Level: --", m_x_pos + 220, y_start + 50, clrWhite, 8);
    CreateLabel(m_prefix + "reason", "Reason: Initializing intelligence engine...", m_x_pos + 10, y_start + 70, clrLightGray, 8);
}

//+------------------------------------------------------------------+
//| Create multi-timeframe section                                  |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateMultiTimeframeSection(void)
{
    int y_start = m_y_pos + 190;
    
    CreateLabel(m_prefix + "mtf_header", "═══ MULTI-TIMEFRAME CONFLUENCE ═══", m_x_pos + 10, y_start, clrCyan, 10);
    CreateLabel(m_prefix + "trend_alignment", "Trend Alignment: --", m_x_pos + 10, y_start + 20, clrWhite, 8);
    CreateLabel(m_prefix + "trend_strength", "Trend Strength: --", m_x_pos + 220, y_start + 20, clrWhite, 8);
    CreateLabel(m_prefix + "timeframes", "Bullish: -- | Bearish: --", m_x_pos + 10, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "momentum", "Momentum: --", m_x_pos + 220, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "edge_strength", "Market Edge: --", m_x_pos + 10, y_start + 50, clrWhite, 8);
    CreateLabel(m_prefix + "confluence", "Confluence Score: --/10", m_x_pos + 220, y_start + 50, clrWhite, 8);
}

//+------------------------------------------------------------------+
//| Create risk scenarios section                                   |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateRiskScenariosSection(void)
{
    int y_start = m_y_pos + 300;
    
    CreateLabel(m_prefix + "risk_header", "═══ RISK SCENARIOS ═══", m_x_pos + 10, y_start, clrCyan, 10);
    CreateLabel(m_prefix + "best_case", "Best Case: +$--", m_x_pos + 10, y_start + 20, clrLimeGreen, 8);
    CreateLabel(m_prefix + "base_case", "Expected: +$--", m_x_pos + 150, y_start + 20, clrYellow, 8);
    CreateLabel(m_prefix + "worst_case", "Worst Case: -$--", m_x_pos + 280, y_start + 20, clrOrangeRed, 8);
    CreateLabel(m_prefix + "max_risk", "Max Risk: --%", m_x_pos + 10, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "risk_assessment", "Assessment: --", m_x_pos + 150, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "exit_strategy", "Exit Strategy: --", m_x_pos + 10, y_start + 50, clrLightGray, 8);
}

//+------------------------------------------------------------------+
//| Create performance section                                      |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreatePerformanceSection(void)
{
    int y_start = m_y_pos + 410;
    
    CreateLabel(m_prefix + "perf_header", "═══ PERFORMANCE INTELLIGENCE ═══", m_x_pos + 10, y_start, clrCyan, 10);
    CreateLabel(m_prefix + "daily_pnl", "Today: +0.00% (+$0)", m_x_pos + 10, y_start + 20, clrWhite, 8);
    CreateLabel(m_prefix + "win_rate", "Win Rate: --%", m_x_pos + 220, y_start + 20, clrWhite, 8);
    CreateLabel(m_prefix + "avg_rr", "Avg R:R: --", m_x_pos + 10, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "best_strategy", "Best Strategy: --", m_x_pos + 150, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "performance_trend", "Trend: --", m_x_pos + 10, y_start + 50, clrWhite, 8);
    CreateLabel(m_prefix + "account_balance", "Balance: $--", m_x_pos + 220, y_start + 50, clrWhite, 8);
}

//+------------------------------------------------------------------+
//| Create system status section                                    |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateSystemStatusSection(void)
{
    int y_start = m_y_pos + 520;
    
    CreateLabel(m_prefix + "status_header", "═══ SYSTEM STATUS ═══", m_x_pos + 10, y_start, clrCyan, 10);
    CreateLabel(m_prefix + "ai_engine", "AI Engine: CONNECTED", m_x_pos + 10, y_start + 20, clrLimeGreen, 8);
    CreateLabel(m_prefix + "data_feed", "Data Feed: REAL-TIME", m_x_pos + 200, y_start + 20, clrLimeGreen, 8);
    CreateLabel(m_prefix + "last_analysis", "Last Analysis: --", m_x_pos + 10, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "next_update", "Next Update: --", m_x_pos + 200, y_start + 35, clrWhite, 8);
    CreateLabel(m_prefix + "emergency_stop", "Emergency Stop: SAFE", m_x_pos + 10, y_start + 50, clrLimeGreen, 8);
}

//+------------------------------------------------------------------+
//| Update trading intelligence display                              |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateTradingIntelligenceDisplay(void)
{
    // Update signal
    string signal_text = "Signal: ";
    color signal_color = clrGray;
    if (m_trading_intel.signal == SIGNAL_BUY)
    {
        signal_text += "BUY " + m_symbol;
        signal_color = clrLimeGreen;
    }
    else if (m_trading_intel.signal == SIGNAL_SELL)
    {
        signal_text += "SELL " + m_symbol;
        signal_color = clrOrangeRed;
    }
    else
    {
        signal_text += "HOLD";
        signal_color = clrYellow;
    }
    
    ObjectSetString(0, m_prefix + "signal", OBJPROP_TEXT, signal_text);
    ObjectSetInteger(0, m_prefix + "signal", OBJPROP_COLOR, signal_color);
    
    // Update conviction
    ObjectSetString(0, m_prefix + "conviction", OBJPROP_TEXT, 
                   "Conviction: " + ConvictionToString(m_trading_intel.conviction));
    ObjectSetInteger(0, m_prefix + "conviction", OBJPROP_COLOR, 
                    GetConvictionColor(m_trading_intel.conviction));
    
    // Update probability
    ObjectSetString(0, m_prefix + "probability", OBJPROP_TEXT, 
                   "Success Probability: " + DoubleToString(m_trading_intel.probability_success * 100, 1) + "%");
    
    // Update risk:reward
    ObjectSetString(0, m_prefix + "risk_reward", OBJPROP_TEXT, 
                   "Risk:Reward = 1:" + DoubleToString(m_trading_intel.risk_reward_ratio, 1));
    
    // Update position size
    ObjectSetString(0, m_prefix + "position_size", OBJPROP_TEXT, 
                   "Optimal Size: " + DoubleToString(m_trading_intel.optimal_position_size, 1) + "%");
    
    // Update key level
    ObjectSetString(0, m_prefix + "key_level", OBJPROP_TEXT, m_trading_intel.key_level);
    
    // Update reason
    ObjectSetString(0, m_prefix + "reason", OBJPROP_TEXT, "Reason: " + m_trading_intel.reason);
}

//+------------------------------------------------------------------+
//| Update multi-timeframe display                                  |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateMultiTimeframeDisplay(void)
{
    // Update trend alignment
    string alignment_text = "Trend Alignment: " + (m_mtf_intel.trend_alignment ? "STRONG" : "WEAK");
    color alignment_color = m_mtf_intel.trend_alignment ? clrLimeGreen : clrOrangeRed;
    ObjectSetString(0, m_prefix + "trend_alignment", OBJPROP_TEXT, alignment_text);
    ObjectSetInteger(0, m_prefix + "trend_alignment", OBJPROP_COLOR, alignment_color);
    
    // Update trend strength
    ObjectSetString(0, m_prefix + "trend_strength", OBJPROP_TEXT, 
                   "Strength: " + m_mtf_intel.trend_strength);
    
    // Update timeframes
    ObjectSetString(0, m_prefix + "timeframes", OBJPROP_TEXT, 
                   "Bullish: " + IntegerToString(m_mtf_intel.bullish_timeframes) + 
                   " | Bearish: " + IntegerToString(m_mtf_intel.bearish_timeframes));
    
    // Update momentum
    ObjectSetString(0, m_prefix + "momentum", OBJPROP_TEXT, 
                   "Momentum: " + m_mtf_intel.momentum_state);
    
    // Update edge strength
    ObjectSetString(0, m_prefix + "edge_strength", OBJPROP_TEXT, 
                   "Market Edge: " + EdgeToString(m_mtf_intel.edge_strength));
    ObjectSetInteger(0, m_prefix + "edge_strength", OBJPROP_COLOR, 
                    GetEdgeColor(m_mtf_intel.edge_strength));
    
    // Calculate confluence score
    int confluence_score = (int)m_mtf_intel.edge_strength * 2 + 
                          (m_mtf_intel.trend_alignment ? 2 : 0);
    ObjectSetString(0, m_prefix + "confluence", OBJPROP_TEXT, 
                   "Confluence: " + IntegerToString(confluence_score) + "/10");
}

//+------------------------------------------------------------------+
//| Update risk scenarios display                                   |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateRiskScenariosDisplay(void)
{
    ObjectSetString(0, m_prefix + "best_case", OBJPROP_TEXT, 
                   "Best: +$" + DoubleToString(m_risk_scenarios.best_case_pnl, 0));
    
    ObjectSetString(0, m_prefix + "base_case", OBJPROP_TEXT, 
                   "Expected: +$" + DoubleToString(m_risk_scenarios.base_case_pnl, 0));
    
    ObjectSetString(0, m_prefix + "worst_case", OBJPROP_TEXT, 
                   "Worst: -$" + DoubleToString(MathAbs(m_risk_scenarios.worst_case_pnl), 0));
    
    ObjectSetString(0, m_prefix + "max_risk", OBJPROP_TEXT, 
                   "Max Risk: " + DoubleToString(m_risk_scenarios.max_account_risk, 1) + "%");
    
    ObjectSetString(0, m_prefix + "risk_assessment", OBJPROP_TEXT, 
                   "Risk: " + m_risk_scenarios.risk_assessment);
    
    ObjectSetString(0, m_prefix + "exit_strategy", OBJPROP_TEXT, 
                   "Exit: " + m_risk_scenarios.exit_strategy);
}

//+------------------------------------------------------------------+
//| Update performance display                                      |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdatePerformanceDisplay(void)
{
    // Update daily P&L
    string pnl_sign = (m_performance_intel.daily_pnl_pct >= 0) ? "+" : "";
    color pnl_color = (m_performance_intel.daily_pnl_pct >= 0) ? clrLimeGreen : clrOrangeRed;
    
    ObjectSetString(0, m_prefix + "daily_pnl", OBJPROP_TEXT, 
                   "Today: " + pnl_sign + DoubleToString(m_performance_intel.daily_pnl_pct, 2) + "% (" + 
                   pnl_sign + "$" + DoubleToString(m_performance_intel.daily_pnl_dollar, 0) + ")");
    ObjectSetInteger(0, m_prefix + "daily_pnl", OBJPROP_COLOR, pnl_color);
    
    // Update win rate
    ObjectSetString(0, m_prefix + "win_rate", OBJPROP_TEXT, 
                   "Win Rate: " + DoubleToString(m_performance_intel.recent_win_rate * 100, 1) + "%");
    
    // Update average R:R
    ObjectSetString(0, m_prefix + "avg_rr", OBJPROP_TEXT, 
                   "Avg R:R: 1:" + DoubleToString(m_performance_intel.avg_risk_reward, 1));
    
    // Update best strategy
    ObjectSetString(0, m_prefix + "best_strategy", OBJPROP_TEXT, 
                   "Best: " + m_performance_intel.best_strategy);
    
    // Update performance trend
    ObjectSetString(0, m_prefix + "performance_trend", OBJPROP_TEXT, 
                   "Trend: " + m_performance_intel.performance_trend);
    
    // Update account balance
    ObjectSetString(0, m_prefix + "account_balance", OBJPROP_TEXT, 
                   "Balance: $" + DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), 0));
}

//+------------------------------------------------------------------+
//| Update system status display                                    |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::UpdateSystemStatusDisplay(void)
{
    // Update last analysis time
    ObjectSetString(0, m_prefix + "last_analysis", OBJPROP_TEXT, 
                   "Last Analysis: " + TimeToString(m_last_intelligence_update, TIME_MINUTES));
    
    // Calculate next update
    datetime next_update = m_last_intelligence_update + 30;
    int seconds_until = (int)(next_update - TimeCurrent());
    ObjectSetString(0, m_prefix + "next_update", OBJPROP_TEXT, 
                   "Next Update: " + IntegerToString(MathMax(0, seconds_until)) + "s");
}

//+------------------------------------------------------------------+
//| Utility methods                                                 |
//+------------------------------------------------------------------+
void RevolutionaryDashboard::CreateLabel(string name, string text, int x, int y, color clr = clrWhite, int size = 8)
{
    ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
    ObjectSetString(0, name, OBJPROP_TEXT, text);
    ObjectSetString(0, name, OBJPROP_FONT, "Consolas");
    ObjectSetInteger(0, name, OBJPROP_FONTSIZE, size);
    ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
    ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
    ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
    ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
}

void RevolutionaryDashboard::CreateRectangle(string name, int x, int y, int width, int height, color bg_color)
{
    ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
    ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
    ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
    ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
    ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
    ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
    ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bg_color);
    ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
    ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
    ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, C'40,45,55');
}

color RevolutionaryDashboard::GetConvictionColor(ENUM_CONVICTION_LEVEL conviction)
{
    switch(conviction)
    {
        case CONVICTION_VERY_STRONG: return clrLimeGreen;
        case CONVICTION_STRONG: return clrGreen;
        case CONVICTION_MODERATE: return clrYellow;
        case CONVICTION_WEAK: return clrOrange;
        default: return clrGray;
    }
}

color RevolutionaryDashboard::GetEdgeColor(ENUM_EDGE_STRENGTH edge)
{
    switch(edge)
    {
        case EDGE_VERY_STRONG: return clrLimeGreen;
        case EDGE_STRONG: return clrGreen;
        case EDGE_MODERATE: return clrYellow;
        case EDGE_WEAK: return clrOrange;
        case EDGE_NONE: return clrGray;
        default: return clrGray;
    }
}

string RevolutionaryDashboard::ConvictionToString(ENUM_CONVICTION_LEVEL conviction)
{
    switch(conviction)
    {
        case CONVICTION_VERY_STRONG: return "VERY STRONG";
        case CONVICTION_STRONG: return "STRONG";
        case CONVICTION_MODERATE: return "MODERATE";
        case CONVICTION_WEAK: return "WEAK";
        default: return "NONE";
    }
}

string RevolutionaryDashboard::EdgeToString(ENUM_EDGE_STRENGTH edge)
{
    switch(edge)
    {
        case EDGE_VERY_STRONG: return "VERY STRONG";
        case EDGE_STRONG: return "STRONG";
        case EDGE_MODERATE: return "MODERATE";
        case EDGE_WEAK: return "WEAK";
        case EDGE_NONE: return "NONE";
        default: return "NONE";
    }
}

//+------------------------------------------------------------------+
//| Get market edge data                                            |
//+------------------------------------------------------------------+
MarketEdge RevolutionaryDashboard::GetMarketEdge(void)
{
    MarketEdge edge;
    edge.strength = m_mtf_intel.edge_strength;
    edge.confidence = (double)m_mtf_intel.edge_strength / 4.0; // Convert to 0-1 scale
    edge.trend_alignment = m_mtf_intel.trend_alignment;
    edge.supporting_timeframes = MathMax(m_mtf_intel.bullish_timeframes, m_mtf_intel.bearish_timeframes);
    edge.reason = "Edge: " + EdgeToString(edge.strength) + " | Momentum: " + m_mtf_intel.momentum_state;
    return edge;
}

//+------------------------------------------------------------------+
//| Get risk scenario data (singular for EA compatibility)          |
//+------------------------------------------------------------------+
RiskScenario RevolutionaryDashboard::GetRiskScenario(void)
{
    RiskScenario scenario;
    
    // Convert RiskScenarios (plural) to RiskScenario (singular) format
    double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (account_balance > 0)
    {
        scenario.best_case_profit = (m_risk_scenarios.best_case_pnl / account_balance) * 100.0;
        scenario.base_case_profit = (m_risk_scenarios.base_case_pnl / account_balance) * 100.0;
        scenario.base_case_loss = MathAbs(m_risk_scenarios.base_case_pnl / account_balance) * 50.0; // 50% of base case
        scenario.worst_case_loss = MathAbs(m_risk_scenarios.worst_case_pnl / account_balance) * 100.0;
    }
    else
    {
        scenario.best_case_profit = 0;
        scenario.base_case_profit = 0;
        scenario.base_case_loss = 0;
        scenario.worst_case_loss = 0;
    }
    
    scenario.max_account_risk = m_risk_scenarios.max_account_risk;
    scenario.risk_level = m_risk_scenarios.risk_assessment;
    scenario.exit_strategy = m_risk_scenarios.exit_strategy;
    
    return scenario;
}

void RevolutionaryDashboard::Destroy(void)
{
    if (!m_initialized) return;
    
    CleanupObjects();
    m_initialized = false;
    ChartRedraw();
}

void RevolutionaryDashboard::CleanupObjects(void)
{
    ObjectsDeleteAll(0, m_prefix, -1, -1);
}

#endif // REVOLUTIONARY_DASHBOARD_MQH