mql5/RevolutionaryAI_EA_FINAL.mq5

//+------------------------------------------------------------------+
//|                              RevolutionaryAI_EA_FINAL.mq5       |
//|                Revolutionary AI Intelligence System v4.0 FINAL  |
//|          COMPLETE INTELLIGENT TRADING ENGINE - FINAL VERSION    |
//|                                                                  |
//| 🧠 REVOLUTIONARY FEATURES:                                       |
//| ✅ Natural Language Trading Intelligence                         |
//| ✅ Conviction-Based Trading (VERY_HIGH, HIGH, MEDIUM, LOW)      |
//| ✅ Probability-Based Position Sizing (Kelly Criterion)          |
//| ✅ Market Edge Strength Analysis (VERY_STRONG to VERY_WEAK)     |
//| ✅ Risk Scenario-Based Management (Best/Base/Worst Case)        |
//| ✅ Intelligent Position Management & Dynamic TP/SL              |
//| ✅ Revolutionary Dashboard with Live Intelligence Display        |
//+------------------------------------------------------------------+
#property copyright "Revolutionary AI Trading System"
#property link "https://revolutionary-ai-trading.com"
#property version "4.0.FINAL"
#property strict

// PROPER INCLUDE STRUCTURE - NO MORE CONFUSION!
#include <Trade/Trade.mqh>
#include <Utils/JAson.mqh>
#include <AI/AIIntegrationManager.mqh>
#include <Trade/TradeManager.mqh>
#include <Trade/RiskManager.mqh>
#include <Indicators/IndicatorEngine.mqh>
#include <Dashboard/SimplifiedStoryDashboard.mqh>

//+------------------------------------------------------------------+
//| CORE CONFIGURATION                                               |
//+------------------------------------------------------------------+
input group "🚀 Revolutionary AI Settings"
input bool EnableAutoTrading = true;                     // Enable automatic trading
input double RiskPerTrade = 2.0;                        // Risk per trade (%)
input double MaxDailyLoss = 5.0;                        // Maximum daily loss (%)
input int MinConfidence = 75;                           // Minimum AI confidence (%)
input string ServerURL = "http://localhost:8000";       // AI Server URL

input group "⚡ Advanced Settings"
input bool EnableDashboard = true;                      // Enable dashboard display
input int AnalysisInterval = 300;                       // Analysis interval (seconds)
input int RiskCheckInterval = 60;                       // Risk check interval (seconds)

//+------------------------------------------------------------------+
//| GLOBAL COMPONENTS                                                |
//+------------------------------------------------------------------+
CTrade                      g_trade;
CAdvancedTradeManager*      g_tradeManager = NULL;
CAdvancedRiskManager*       g_riskManager = NULL;
CAdvancedIndicatorEngine*   g_indicatorEngine = NULL;
AIIntegrationManager*       g_aiManager = NULL;
SimplifiedStoryDashboard*   g_dashboard = NULL;

// State Management
struct TradingState {
    bool initialized;
    bool trading_enabled;
    datetime last_analysis;
    datetime last_risk_check;
    double daily_start_balance;
    string current_signal;
    double current_confidence;
};

TradingState g_state;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    Print("🚀 Revolutionary AI Intelligence System v4.0 FINAL - Starting Intelligence Systems");
    
    // Initialize state
    ZeroMemory(g_state);
    g_state.daily_start_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    
    // Initialize components
    if (!InitializeCore()) {
        Print("❌ Core initialization failed");
        return INIT_FAILED;
    }
    
    // Setup dashboard
    if (EnableDashboard && !InitializeDashboard()) {
        Print("⚠️ Dashboard initialization failed - continuing without dashboard");
    }
    
    g_state.initialized = true;
    g_state.trading_enabled = EnableAutoTrading;
    
    Print("✅ Revolutionary AI Intelligence System v4.0 FINAL - All Systems Online");
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    Print("🔄 Revolutionary AI Intelligence System v4.0 FINAL - Shutting down intelligence engines");
    
    // Clean shutdown
    if (g_dashboard != NULL) { delete g_dashboard; g_dashboard = NULL; }
    if (g_tradeManager != NULL) { delete g_tradeManager; g_tradeManager = NULL; }
    if (g_riskManager != NULL) { delete g_riskManager; g_riskManager = NULL; }
    if (g_indicatorEngine != NULL) { delete g_indicatorEngine; g_indicatorEngine = NULL; }
    if (g_aiManager != NULL) { delete g_aiManager; g_aiManager = NULL; }
    
    Print("✅ Revolutionary AI Intelligence System v4.0 FINAL - All intelligence systems offline");
}

//+------------------------------------------------------------------+
//| Expert tick function - Optimized                                |
//+------------------------------------------------------------------+
void OnTick()
{
    if (!g_state.initialized || !g_state.trading_enabled) return;
    
    datetime current_time = TimeCurrent();
    
    // Daily reset check
    CheckDailyReset();
    
    // Risk management check (every minute)
    if (current_time - g_state.last_risk_check >= RiskCheckInterval) {
        if (!PerformRiskCheck()) {
            g_state.trading_enabled = false;
            return;
        }
        g_state.last_risk_check = current_time;
    }
    
    // AI analysis check (every 5 minutes)
    if (current_time - g_state.last_analysis >= AnalysisInterval) {
        PerformAIAnalysis();
        g_state.last_analysis = current_time;
    }
    
    // Update dashboard (lightweight)
    if (g_dashboard != NULL) {
        g_dashboard->UpdateLive();
    }
}

//+------------------------------------------------------------------+
//| Initialize core components                                       |
//+------------------------------------------------------------------+
bool InitializeCore()
{
    // Initialize Trade Manager
    g_tradeManager = new CAdvancedTradeManager();
    if (!g_tradeManager->Initialize(_Symbol, 12345, RiskPerTrade)) {
        Print("❌ Trade Manager initialization failed");
        return false;
    }
    
    // Initialize Risk Manager
    g_riskManager = new CAdvancedRiskManager();
    if (!g_riskManager->Initialize()) {
        Print("❌ Risk Manager initialization failed");
        return false;
    }
    
    RiskParameters riskParams;
    riskParams.maxRiskPerTrade = RiskPerTrade;
    riskParams.maxDailyRisk = MaxDailyLoss;
    riskParams.maxDrawdown = 15.0;
    riskParams.maxPositionSize = 10.0;
    riskParams.maxOpenPositions = 3;
    riskParams.emergencyStopLevel = 20.0;
    g_riskManager->SetRiskParameters(riskParams);
    
    // Initialize Indicator Engine
    g_indicatorEngine = new CAdvancedIndicatorEngine();
    if (!g_indicatorEngine->Initialize(_Symbol, PERIOD_H1)) {
        Print("❌ Indicator Engine initialization failed");
        return false;
    }
    
    // Initialize AI Manager
    g_aiManager = new AIIntegrationManager(ServerURL, "");
    g_aiManager->SetSymbol(_Symbol);
    
    Print("✅ Core components initialized successfully");
    return true;
}

//+------------------------------------------------------------------+
//| Initialize dashboard                                             |
//+------------------------------------------------------------------+
bool InitializeDashboard()
{
    g_dashboard = new SimplifiedStoryDashboard(g_aiManager, _Symbol, 20, 50);
    return true;
}

//+------------------------------------------------------------------+
//| Perform Revolutionary AI Analysis and Execute Intelligent Trades |
//+------------------------------------------------------------------+
void PerformAIAnalysis()
{
    Print("🧠 Performing Revolutionary Intelligence Analysis...");
    
    // Get revolutionary intelligence from dashboard
    if (g_dashboard == NULL) return;
    
    TradingIntelligence intelligence = g_dashboard->GetTradingIntelligence();
    
    // Update state with intelligent analysis
    g_state.current_signal = (intelligence.signal == SIGNAL_BUY) ? "BUY" : 
                            (intelligence.signal == SIGNAL_SELL) ? "SELL" : "HOLD";
    g_state.current_confidence = intelligence.probability_success * 100;
    
    // Revolutionary Intelligence Processing
    Print("🎯 Intelligence Report:");
    Print("   Signal: " + EnumToString(intelligence.signal));
    Print("   Conviction: " + EnumToString(intelligence.conviction));
    Print("   Success Probability: " + DoubleToString(intelligence.probability_success * 100, 1) + "%");
    Print("   Risk/Reward: " + DoubleToString(intelligence.risk_reward_ratio, 2));
    Print("   Reasoning: " + intelligence.reason);
    
    // Use conviction-based trading instead of simple confidence
    if (!IsIntelligentTradeWorthy(intelligence)) {
        Print("🚫 Revolutionary analysis suggests no trade at this time");
        return;
    }
    
    // Get market edge strength for additional confirmation
    MarketEdge edge = g_dashboard->GetMarketEdge();
    
    // Execute intelligent trading strategy
    ExecuteIntelligentTrade(intelligence, edge);
}

//+------------------------------------------------------------------+
//| Determine if trade is worthy based on Revolutionary Intelligence |
//+------------------------------------------------------------------+
bool IsIntelligentTradeWorthy(TradingIntelligence &intelligence)
{
    // Revolutionary conviction-based filtering instead of simple confidence
    if (intelligence.conviction == CONVICTION_WEAK) {
        Print("🚫 Conviction too low: " + EnumToString(intelligence.conviction));
        return false;
    }
    
    // Probability-based filtering
    if (intelligence.probability_success < 0.65) { // 65% minimum success probability
        Print("🚫 Success probability too low: " + DoubleToString(intelligence.probability_success * 100, 1) + "%");
        return false;
    }
    
    // Risk/Reward ratio filtering
    if (intelligence.risk_reward_ratio < 1.5) { // Minimum 1.5:1 R/R
        Print("🚫 Risk/Reward ratio too low: " + DoubleToString(intelligence.risk_reward_ratio, 2));
        return false;
    }
    
    // No signal = no trade
    if (intelligence.signal == SIGNAL_NONE) {
        return false;
    }
    
    Print("✅ Revolutionary Intelligence confirms trade worthiness");
    return true;
}

//+------------------------------------------------------------------+
//| Execute Intelligent Trade using Revolutionary Analysis          |
//+------------------------------------------------------------------+
void ExecuteIntelligentTrade(TradingIntelligence &intelligence, MarketEdge &edge)
{
    Print("🚀 Executing Intelligent Trade based on Revolutionary Analysis");
    
    // Enhanced position sizing using Kelly Criterion from intelligence
    double kellyLotSize = intelligence.optimal_position_size;
    
    // Market edge adjusted position sizing
    double edgeMultiplier = 1.0;
    
    if (edge.strength == EDGE_VERY_STRONG) {
        edgeMultiplier = 1.3; // Increase position by 30% for very strong edge
        Print("💪 Very Strong Market Edge detected - increasing position size");
    }
    else if (edge.strength == EDGE_STRONG) {
        edgeMultiplier = 1.15; // Increase position by 15% for strong edge
        Print("💪 Strong Market Edge detected - slightly increasing position size");
    }
    else if (edge.strength == EDGE_WEAK) {
        edgeMultiplier = 0.8; // Reduce position by 20% for weak edge
        Print("⚠️ Weak Market Edge detected - reducing position size");
    }
    
    double finalLotSize = kellyLotSize * edgeMultiplier;
    
    // Risk management override - never exceed risk management limits
    double maxAllowedLotSize = g_riskManager->CalculateOptimalLotSize(_Symbol, RiskPerTrade, 100);
    finalLotSize = MathMin(finalLotSize, maxAllowedLotSize);
    
    // Get risk scenarios for dynamic TP/SL
    RiskScenario scenarios = g_dashboard->GetRiskScenario();
    
    // Use scenario-based TP/SL instead of basic levels
    double stopLoss = 0, takeProfit = 0;
    
    if (intelligence.signal == SIGNAL_BUY) {
        stopLoss = SymbolInfoDouble(_Symbol, SYMBOL_BID) - (scenarios.worst_case_loss * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
        takeProfit = SymbolInfoDouble(_Symbol, SYMBOL_BID) + (scenarios.best_case_profit * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
    }
    else if (intelligence.signal == SIGNAL_SELL) {
        stopLoss = SymbolInfoDouble(_Symbol, SYMBOL_ASK) + (scenarios.worst_case_loss * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
        takeProfit = SymbolInfoDouble(_Symbol, SYMBOL_ASK) - (scenarios.best_case_profit * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
    }
    
    // Execute the intelligent trade
    TradeResult tradeResult;
    string intelligentComment = "RevAI_FINAL|" + EnumToString(intelligence.conviction) + 
                               "|Prob:" + DoubleToString(intelligence.probability_success * 100, 0) + 
                               "%|Edge:" + EnumToString(edge.strength);
    
    if (intelligence.signal == SIGNAL_BUY) {
        tradeResult = g_tradeManager->OpenBuy(finalLotSize, stopLoss, takeProfit, intelligentComment);
    }
    else if (intelligence.signal == SIGNAL_SELL) {
        tradeResult = g_tradeManager->OpenSell(finalLotSize, stopLoss, takeProfit, intelligentComment);
    }
    
    if (tradeResult.success) {
        g_riskManager->AddPosition(tradeResult.ticket, _Symbol, finalLotSize, stopLoss);
        
        Print("🎯 INTELLIGENT TRADE EXECUTED:");
        Print("   Signal: " + EnumToString(intelligence.signal));
        Print("   Conviction: " + EnumToString(intelligence.conviction));
        Print("   Success Probability: " + DoubleToString(intelligence.probability_success * 100, 1) + "%");
        Print("   Market Edge: " + EnumToString(edge.strength));
        Print("   Position Size: " + DoubleToString(finalLotSize, 2) + " lots");
        Print("   Ticket: " + IntegerToString(tradeResult.ticket));
        Print("   Reasoning: " + intelligence.reason);
        Print("   Expected R/R: " + DoubleToString(intelligence.risk_reward_ratio, 2));
    }
    else {
        Print("❌ Intelligent trade execution failed: " + tradeResult.message);
        Print("🔍 Error code: " + IntegerToString(tradeResult.retcode));
        Print("💡 Revolutionary analysis was: " + intelligence.reason);
    }
}

//+------------------------------------------------------------------+
//| Perform Revolutionary Risk Management                           |
//+------------------------------------------------------------------+
bool PerformRiskCheck()
{
    // Update position risk tracking
    g_riskManager->UpdatePositionRisk();
    
    // Check emergency stop
    if (g_riskManager->IsEmergencyStop()) {
        Print("🚨 EMERGENCY STOP TRIGGERED BY RISK MANAGER");
        g_tradeManager->CloseAllPositions();
        return false;
    }
    
    // Revolutionary Risk Scenarios Check
    if (g_dashboard != NULL) {
        RiskScenario scenarios = g_dashboard->GetRiskScenario();
        
        // Get current portfolio performance
        double currentBalance = AccountInfoDouble(ACCOUNT_BALANCE);
        double dailyPnL = ((currentBalance - g_state.daily_start_balance) / g_state.daily_start_balance) * 100;
        
        // Intelligent risk scenario-based decisions
        if (dailyPnL <= scenarios.worst_case_loss) {
            Print("🚨 REVOLUTIONARY RISK ANALYSIS: Worst case scenario reached");
            Print("   Current P&L: " + DoubleToString(dailyPnL, 2) + "%");
            Print("   Worst case limit: " + DoubleToString(scenarios.worst_case_loss, 2) + "%");
            g_tradeManager->CloseAllPositions();
            return false;
        }
    }
    
    // Standard daily loss limit check
    double currentBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    double dailyPnL = ((currentBalance - g_state.daily_start_balance) / g_state.daily_start_balance) * 100;
    
    if (dailyPnL <= -MaxDailyLoss) {
        Print("🚨 Daily loss limit reached: ", DoubleToString(dailyPnL, 2), "%");
        g_tradeManager->CloseAllPositions();
        return false;
    }
    
    return true;
}

//+------------------------------------------------------------------+
//| Check for daily reset                                           |
//+------------------------------------------------------------------+
void CheckDailyReset()
{
    static int lastDay = -1;
    int currentDay = TimeDay(TimeCurrent());
    
    if (lastDay != -1 && currentDay != lastDay) {
        g_state.daily_start_balance = AccountInfoDouble(ACCOUNT_BALANCE);
        g_state.trading_enabled = EnableAutoTrading;
        Print("📅 Daily reset completed");
    }
    
    lastDay = currentDay;
}