SAM.mq5

#property copyright "Jason.W.Rusk@gmail.com"
#property version   "3.00" // HTTP Communication Update

#include <Trade/Trade.mqh>
#include <Files/File.mqh>
#include <stdlib.mqh>
#include <Math/Stat/Math.mqh>

// --- TYPE DEFINITIONS ---
enum ENUM_TRADING_MODE { MODE_TRADING_DISABLED, MODE_REGRESSION_ONLY, MODE_COMBINED };
enum ENUM_STOP_LOSS_MODE { SL_ATR_BASED, SL_STATIC_PIPS };
enum ENUM_TAKE_PROFIT_MODE { TP_REGRESSION_TARGET, TP_ATR_MULTIPLE, TP_STATIC_PIPS };
enum ENUM_TARGET_BAR { H_PLUS_1=0, H_PLUS_2, H_PLUS_3, H_PLUS_4, H_PLUS_5 };
enum ENUM_ADAPTIVE_MODE { ADAPTIVE_DISABLED, ADAPTIVE_CONSERVATIVE, ADAPTIVE_AGGRESSIVE };

// --- HTTP COMMUNICATION SETTINGS ---
input group    "=== HTTP DAEMON COMMUNICATION ===";
input string DaemonHost = "127.0.0.1";                    // Daemon server host
input int    DaemonPort = 8888;                           // Daemon server port
input int    HttpTimeoutMs = 15000;                       // HTTP request timeout (ms)
input int    MaxRetryAttempts = 3;                        // Max retry attempts for failed requests
input int    RetryDelayMs = 1000;                         // Delay between retries (ms)
input bool   EnableHttpLogging = true;                    // Enable detailed HTTP logging
input bool   TestDaemonOnStart = false;                   // Test daemon communication on startup

// --- KELLY CRITERION INPUTS ---
input group    "=== KELLY CRITERION POSITION SIZING ===";
input bool   EnableKellyCriterion = true;              // Enable Kelly Criterion position sizing
input double MaxKellyFraction = 0.25;                  // Maximum Kelly fraction (25% recommended)
input double MinKellyFraction = 0.01;                  // Minimum Kelly fraction (1% minimum)
input int    KellyLookbackTrades = 30;                 // Number of recent trades for Kelly calculation
input double KellyMultiplier = 0.5;                    // Kelly fraction multiplier (0.5 = Half-Kelly)
input bool   UseConfidenceScaling = true;              // Scale Kelly by prediction confidence
input double BaseRiskWhenNoHistory = 2.0;              // Risk % when insufficient trade history
input bool   EnableKellySmoothing = true;              // Smooth Kelly changes to prevent whipsawing
input double KellySmoothingFactor = 0.3;               // Smoothing factor (0.1-0.5 recommended)

// --- TRADING HOURS INPUTS ---
input group    "=== TRADING HOURS CONTROL ===";
input bool   EnableTradingHours = false;           // Enable/disable trading hours filter
input int    TradingStartHour = 8;                 // Start trading hour (0-23)
input int    TradingEndHour = 18;                  // End trading hour (0-23)
input bool   TradingMonday = true;                 // Trade on Monday
input bool   TradingTuesday = true;                // Trade on Tuesday
input bool   TradingWednesday = true;              // Trade on Wednesday
input bool   TradingThursday = true;               // Trade on Thursday
input bool   TradingFriday = true;                 // Trade on Friday
input bool   TradingSaturday = false;              // Trade on Saturday
input bool   TradingSunday = true;                 // Trade on Sunday
input bool   AvoidNewsHours = false;               // Avoid major news hours
input string NewsAvoidanceHours = "14:30-15:30";   // Hours to avoid (format: HH:MM-HH:MM)
input bool   ClosePositionsOutsideHours = false;   // Close positions when outside trading hours

// --- SCALPING STRATEGY INPUTS ---
input group    "=== SCALPING STRATEGY ===";
input bool   EnableScalpingStrategy = true;           // Enable/disable scalping
input double BaseScalpingPips = 10.0;                 // Base pip threshold for scalping
input int    ScalpingTimeoutBars = 3;                // Bars to hold scalping position
input double ScalpingRiskPercent = 1;               // Risk % for scalping (separate from main)
input bool   AdaptiveScalpingThreshold = true;        // Make pip threshold adaptive
input double MinScalpingAccuracy = 0;              // Minimum accuracy required for scalping
input bool   ScalpingOverridesMain = false;           // If true, scalping replaces main strategy

// --- ADAPTIVE LEARNING INPUTS ---
input group    "=== ADAPTIVE LEARNING SYSTEM ===";
input ENUM_ADAPTIVE_MODE AdaptiveLearningMode = ADAPTIVE_CONSERVATIVE;
input bool   EnableDynamicConfidence = true;
input bool   EnableAdaptivePositionSizing = true;
input bool   EnableStepWeighting = true;
input bool   EnableMarketConditionAdaptation = true;
input bool   EnableTesterLearning = true;           // Learn from strategy tester results
input int    AdaptiveLearningPeriod = 50;          // Trades to analyze for adaptation
input double AdaptiveConfidenceRange = 0.30;       // Max confidence adjustment range
input double AdaptiveRiskRange = 2.0;              // Max risk adjustment range
input int    MinTradesForAdaptation = 20;          // Minimum trades before adaptation kicks in
input double TesterLearningWeight = 0.7;           // Weight for tester vs live learning (0.0-1.0)

// --- ORIGINAL INPUT PARAMETERS ---
input group    "Main Settings";
input ENUM_TRADING_MODE TradingLogicMode = MODE_COMBINED;
input bool              EnablePricePredictionDisplay = true;
input bool              EnableDailyPredictionDisplay = true; // Display D1 prediction on chart
input ENUM_TARGET_BAR   TakeProfitTargetBar = H_PLUS_5;

input group    "Risk & Position Management";
input ENUM_STOP_LOSS_MODE   StopLossMode = SL_ATR_BASED;
input ENUM_TAKE_PROFIT_MODE TakeProfitMode = TP_REGRESSION_TARGET;
input bool   UseMarketOrderForTP = false;
input double RiskPercent = 2.0;
input double MinimumRiskRewardRatio = 1.1;
input int    StaticStopLossPips = 300;
input int    StaticTakeProfitPips = 200;
input int    ATR_Period = 14;
input double ATR_SL_Multiplier = 1.5;
input double ATR_TP_Multiplier = 2.0;
input double MinProfitPips = 10.0;
input bool   EnableTimeBasedExit = false;
input int    MaxPositionHoldBars = 12;
input int    InpExitBarMinute = 58;
input bool   EnableTrailingStop = true;
input double TrailingStartPips = 9.0;
input double TrailingStopPips = 2.0;

input group    "Confidence & Filters";
input double MinimumModelConfidence = 0.40;
input double MinimumSignalConfidence = 0.30;
input double ClassificationSignalThreshold = 0.30;
input int    RequiredConsistentSteps = 5;
input bool   EnableADXFilter = true;
input int    ADX_Period = 14;
input int    ADX_Threshold = 25;

input group    "Model & Data Settings";
input int    AccuracyLookaheadBars = 5;
input int    AccuracyLookbackOnInit = 60;
input int    AccuracyWindowBars = 12;
input string Symbol_EURJPY = "EURJPY", Symbol_USDJPY = "USDJPY", Symbol_GBPUSD = "GBPUSD";
input string Symbol_EURGBP = "EURGBP", Symbol_USDCAD = "USDCAD", Symbol_USDCHF = "USDCHF";
input int    PredictionUpdateMinutes = 1;

// --- Constants ---
#define PREDICTION_STEPS 5
#define SEQ_LEN 20
#define FEATURE_COUNT 15
#define GUI_PREFIX "GGTHGUI_"
#define BACKTEST_PREDICTIONS_FILE "backtest_predictions.csv"
#define ADAPTIVE_LEARNING_FILE "adaptive_learning_data.csv"
#define TESTER_RESULTS_FILE "tester_results.csv"

// --- KELLY CRITERION STRUCTURES ---
struct KellyTradeRecord {
    datetime trade_time;
    bool was_profitable;
    double profit_pips;
    double loss_pips;
    double r_multiple;           // Profit/Risk ratio
    double confidence_used;
    ENUM_ORDER_TYPE trade_type;
};

struct KellyMetrics {
    double win_rate;
    double avg_win_pips;
    double avg_loss_pips;
    double avg_r_multiple;
    double profit_factor;
    int total_trades;
    int winning_trades;
    double kelly_fraction;
    double confidence_adjusted_kelly;
};

// --- ADAPTIVE LEARNING STRUCTURES ---
struct TradeRecord 
{
    datetime trade_time;
    double entry_price;
    double exit_price;
    double profit;
    double confidence_used;
    double risk_used;
    int prediction_step_used;
    double accuracy_at_trade;
    bool was_profitable;
    double market_volatility;
    int hour_of_day;
    double drawdown_at_entry;
    double prediction_error;
    bool from_tester;
};

struct AdaptiveMetrics 
{
    double avg_accuracy[PREDICTION_STEPS];
    double step_weights[PREDICTION_STEPS];
    double dynamic_confidence_threshold;
    double dynamic_risk_multiplier;
    double success_rate_last_n_trades;
    double avg_profit_per_trade;
    double volatility_factor;
    int trades_analyzed;
    double max_drawdown_experienced;
    double best_performing_step;
    double worst_performing_step;
};

struct MarketCondition 
{
    double volatility_level;
    int trend_direction;  // -1=bear, 0=sideways, 1=bull
    int session_hour;
    double recent_accuracy;
    double correlation_strength;
};

struct TesterResult 
{
    datetime test_date;
    string symbol;
    string timeframe;
    double total_profit;
    double max_drawdown;
    int total_trades;
    double success_rate;
    double sharpe_ratio;
    double best_confidence_threshold;
    double best_risk_multiplier;
    double avg_step_weight[PREDICTION_STEPS];
    double market_conditions_score;
};

// --- Global Handles & Variables ---
int atr_handle, macd_handle, rsi_handle, stoch_handle, cci_handle, adx_handle, bb_handle;
CTrade trade;
enum ENUM_PREDICTION_DIRECTION { DIR_BULLISH, DIR_BEARISH, DIR_NEUTRAL };

struct StepPrediction 
{
    double target_price;
    datetime prediction_bar_time;
    datetime window_end_time;
    ENUM_PREDICTION_DIRECTION direction;
    int step;
    bool evaluated;
    bool hit_within_window;
};

struct DaemonResponse { double prices[PREDICTION_STEPS]; double confidence_score; double buy_prob; double sell_prob; };

// --- SCALPING STRATEGY STRUCTURES ---
struct ScalpingPosition
{
    bool is_active;
    datetime entry_time;
    double entry_price;
    double target_price;
    int target_step;
    ENUM_ORDER_TYPE order_type;
    double lot_size;
    ulong ticket;
    datetime timeout_time; // This is now a reference time, not the definitive trigger
    string comment;
};

// --- HTTP COMMUNICATION GLOBALS ---
string g_daemon_base_url = "";
int g_http_requests_sent = 0;
int g_http_successful_responses = 0;
int g_http_failed_responses = 0;
datetime g_last_http_request_time = 0;
string g_last_http_error = "";
bool g_daemon_health_checked = false;

// --- KELLY CRITERION GLOBAL VARIABLES ---
KellyTradeRecord g_kelly_trade_history[];
KellyMetrics g_kelly_metrics;
double g_current_kelly_fraction = 0.02;     // Current Kelly fraction
double g_smoothed_kelly_fraction = 0.02;    // Smoothed Kelly fraction
double g_last_calculated_kelly = 0.02;      // Last raw Kelly calculation
datetime g_last_kelly_update = 0;           // Last Kelly update time

// --- ADAPTIVE LEARNING GLOBAL VARIABLES ---
TradeRecord g_trade_history[];
AdaptiveMetrics g_adaptive_metrics;
MarketCondition g_current_market_condition;
TesterResult g_tester_results[];
ScalpingPosition g_scalping_position;               // Current scalping position
datetime g_last_adaptation_time = 0;
bool g_adaptive_system_initialized = false;
bool g_is_tester_mode = false;
double g_tester_start_balance = 0;
double g_max_equity_peak = 0;
double g_current_drawdown = 0;

// Original global variables
StepPrediction g_step_predictions[];
double g_last_predictions[PREDICTION_STEPS];
double g_last_confidence_score = 0.0;
double g_accuracy_pct[PREDICTION_STEPS];
int    g_total_hits[PREDICTION_STEPS], g_total_predictions[PREDICTION_STEPS];
double g_active_trade_target_price = 0;

// NEW: Daily Prediction Globals
double g_last_daily_prediction_price = 0;
ENUM_PREDICTION_DIRECTION g_last_daily_prediction_direction = DIR_NEUTRAL;
datetime g_last_daily_prediction_time = 0;

struct BacktestPrediction { datetime timestamp; double buy_prob, sell_prob, hold_prob, confidence_score; double predicted_prices[PREDICTION_STEPS]; };
BacktestPrediction g_backtest_predictions[];
int g_backtest_prediction_idx = 0;

double g_RiskPercent, g_MinimumRiskRewardRatio, g_ATR_SL_Multiplier, g_ATR_TP_Multiplier, g_MinProfitPips, g_TrailingStartPips, g_TrailingStopPips, g_MinimumModelConfidence, g_MinimumSignalConfidence, g_ClassificationSignalThreshold;
int    g_RequiredConsistentSteps, g_StaticStopLossPips, g_StaticTakeProfitPips, g_ATR_Period, g_MaxPositionHoldBars, g_ExitBarMinute, g_ADX_Period, g_ADX_Threshold, g_AccuracyLookbackOnInit, g_AccuracyWindowBars, g_PredictionUpdateMinutes;
bool   g_EnableTimeBasedExit, g_EnableTrailingStop, g_EnableADXFilter;
ENUM_TRADING_MODE   g_TradingLogicMode;
ENUM_STOP_LOSS_MODE g_StopLossMode;
ENUM_TAKE_PROFIT_MODE g_TakeProfitMode;

datetime g_last_successful_request = 0;
datetime g_last_request_attempt = 0;
datetime g_last_prediction_time = 0;
int g_total_requests_sent = 0;
int g_successful_responses = 0;
string g_connection_status = "Not Connected";
string g_last_error = "";

//+------------------------------------------------------------------+
//| HTTP COMMUNICATION FUNCTIONS
//+------------------------------------------------------------------+

string BuildDaemonUrl(string endpoint = "predict")
{
    return StringFormat("http://%s:%d/%s", DaemonHost, DaemonPort, endpoint);
}

//+------------------------------------------------------------------+
//| PROPERLY FIXED HTTP COMMUNICATION FUNCTIONS
//+------------------------------------------------------------------+

bool CheckDaemonHealth()
{
    if(g_daemon_health_checked) return true;
    
    string health_url = BuildDaemonUrl("health");
    string headers = "Content-Type: application/json\r\n";
    uchar response_data[];
    string response_headers;
    int timeout = 5000; // 5 second timeout for health check
    
    if(EnableHttpLogging)
        PrintFormat("🏥 Checking daemon health: %s", health_url);
    
    // FIXED: Correct WebRequest signature with uchar[] arrays
    uchar empty_data[];
    int result = WebRequest("GET", health_url, headers, timeout, empty_data, response_data, response_headers);
    
    if(result == 200)
    {
        string response_text = CharArrayToString(response_data);
        if(EnableHttpLogging)
            PrintFormat("✅ Daemon health check successful: %s", response_text);
        
        // Parse health response to check model status
        if(StringFind(response_text, "\"status\": \"healthy\"") >= 0 && 
           StringFind(response_text, "\"model_loaded\": true") >= 0)
        {
            g_daemon_health_checked = true;
            return true;
        }
        else
        {
            PrintFormat("❌ Daemon not fully ready: %s", response_text);
            return false;
        }
    }
    else
    {
        g_last_http_error = StringFormat("Health check failed: HTTP %d", result);
        if(EnableHttpLogging)
            PrintFormat("❌ %s", g_last_http_error);
        return false;
    }
}

bool SendHttpRequest(const double &features[], double current_price, double atr_val, DaemonResponse &response)
{
    if(!CheckDaemonHealth()) return false;
    
    g_http_requests_sent++;
    g_last_http_request_time = TimeCurrent();
    
    // Build JSON request
    string request_id = GenerateRequestID();
    string json_request = StringFormat("{\n  \"request_id\": \"%s\",\n", request_id);
    json_request += StringFormat("  \"current_price\": %.8f,\n", current_price);
    json_request += StringFormat("  \"atr\": %.8f,\n", atr_val);
    json_request += "  \"features\": [";
    
    for(int i = 0; i < ArraySize(features); i++)
    {
        json_request += DoubleToString(features[i], 8);
        if(i < ArraySize(features) - 1) json_request += ", ";
    }
    json_request += "]\n}";
    
    // Prepare HTTP request
    string url = BuildDaemonUrl("predict");
    string headers = "Content-Type: application/json\r\n";
    uchar post_data[];
    StringToCharArray(json_request, post_data, 0, StringLen(json_request));
    
    uchar response_data[];
    string response_headers;
    
    if(EnableHttpLogging)
        PrintFormat("📤 Sending HTTP request to: %s (%.2f KB)", url, ArraySize(post_data) / 1024.0);
    
    // Attempt request with retries
    for(int attempt = 1; attempt <= MaxRetryAttempts; attempt++)
    {
        // FIXED: Correct WebRequest signature with uchar[] arrays
        int result = WebRequest("POST", url, headers, HttpTimeoutMs, post_data, response_data, response_headers);
        
        if(result == 200)
        {
            // Successful response
            string response_text = CharArrayToString(response_data);
            
            if(EnableHttpLogging)
                PrintFormat("✅ HTTP response received (attempt %d): %.2f KB", attempt, ArraySize(response_data) / 1024.0);
            
            // Parse response
            if(ParsePredictionResponse(response_text, response))
            {
                g_http_successful_responses++;
                g_connection_status = "Connected";
                g_last_error = "";
                return true;
            }
            else
            {
                g_last_http_error = "Failed to parse response JSON";
                if(EnableHttpLogging)
                    PrintFormat("❌ JSON parsing failed: %s", response_text);
                break;
            }
        }
        else
        {
            // HTTP error
            string error_response = CharArrayToString(response_data);
            g_last_http_error = StringFormat("HTTP %d: %s", result, error_response);
            
            if(EnableHttpLogging)
                PrintFormat("❌ HTTP error (attempt %d/%d): %s", attempt, MaxRetryAttempts, g_last_http_error);
            
            // Check if we should retry
            if(attempt < MaxRetryAttempts)
            {
                if(result == -1) // Network error
                {
                    Sleep(RetryDelayMs * attempt); // Exponential backoff
                    continue;
                }
                else if(result >= 500) // Server error
                {
                    Sleep(RetryDelayMs);
                    continue;
                }
                else // Client error (4xx) - don't retry
                {
                    break;
                }
            }
        }
    }
    
    // All attempts failed
    g_http_failed_responses++;
    g_connection_status = "Error";
    g_last_error = g_last_http_error;
    return false;
}

bool ParsePredictionResponse(string response_text, DaemonResponse &response)
{
    // Check for error status
    if(StringFind(response_text, "\"status\": \"error\"") >= 0)
    {
        // Extract error message
        int msg_start = StringFind(response_text, "\"message\": \"");
        if(msg_start >= 0)
        {
            msg_start += 12; // Length of "\"message\": \""
            int msg_end = StringFind(response_text, "\"", msg_start);
            if(msg_end > msg_start)
            {
                g_last_http_error = "Daemon error: " + StringSubstr(response_text, msg_start, msg_end - msg_start);
            }
        }
        return false;
    }
    
    // Parse predicted prices array
    int prices_start = StringFind(response_text, "\"predicted_prices\"");
    if(prices_start < 0) return false;
    
    int bracket_start = StringFind(response_text, "[", prices_start);
    int bracket_end = StringFind(response_text, "]", bracket_start);
    if(bracket_start < 0 || bracket_end < 0) return false;
    
    string prices_str = StringSubstr(response_text, bracket_start + 1, bracket_end - bracket_start - 1);
    string price_values[];
    if(StringSplit(prices_str, ',', price_values) != PREDICTION_STEPS) return false;
    
    // Convert to double array
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        string clean_price = price_values[i];
        StringTrimLeft(clean_price);
        StringTrimRight(clean_price);
        response.prices[i] = StringToDouble(clean_price);
    }
    
    // Parse other fields
    if(!JsonGetValue(response_text, "confidence_score", response.confidence_score)) return false;
    if(!JsonGetValue(response_text, "buy_probability", response.buy_prob)) return false;
    if(!JsonGetValue(response_text, "sell_probability", response.sell_prob)) return false;
    
    return true;
}

bool TestDaemonCommunication()
{
    PrintFormat("🧪 TESTING HTTP DAEMON COMMUNICATION...");
    PrintFormat("   Target: %s", BuildDaemonUrl());
    
    // Test health endpoint first
    if(!CheckDaemonHealth())
    {
        PrintFormat("❌ DAEMON HEALTH CHECK FAILED!");
        PrintFormat("   Make sure the daemon is running: python daemon_http.py");
        PrintFormat("   Check if URL '%s' is in allowed URLs list", BuildDaemonUrl("health"));
        return false;
    }
    
    PrintFormat("✅ Daemon health check passed!");
    
    // Test prediction endpoint
    double test_features[FEATURE_COUNT * SEQ_LEN];
    for(int i = 0; i < ArraySize(test_features); i++)
    {
        test_features[i] = 0.001 * (i % 20); // Simple test data
    }
    
    MqlTick tick;
    if(!SymbolInfoTick(_Symbol, tick))
    {
        PrintFormat("❌ Could not get current tick for test");
        return false;
    }
    
    DaemonResponse test_response;
    PrintFormat("📤 Sending test prediction request...");
    
    if(SendHttpRequest(test_features, tick.ask, 0.0010, test_response))
    {
        PrintFormat("✅✅✅ HTTP DAEMON TEST SUCCESSFUL! ✅✅✅");
        PrintFormat("   Confidence: %.3f", test_response.confidence_score);
        PrintFormat("   Buy Probability: %.3f", test_response.buy_prob);
        PrintFormat("   Sell Probability: %.3f", test_response.sell_prob);
        PrintFormat("   First Predicted Price: %.5f", test_response.prices[0]);
        PrintFormat("   HTTP Requests: %d successful, %d failed", g_http_successful_responses, g_http_failed_responses);
        return true;
    }
    else
    {
        PrintFormat("❌❌❌ HTTP DAEMON TEST FAILED! ❌❌❌");
        PrintFormat("   Error: %s", g_last_http_error);
        PrintFormat("   Connection Status: %s", g_connection_status);
        
        PrintFormat("\n🔧 TROUBLESHOOTING STEPS:");
        PrintFormat("1. Ensure daemon is running: python daemon_http.py");
        PrintFormat("2. Check daemon console for errors");
        PrintFormat("3. Verify daemon host:port: %s:%d", DaemonHost, DaemonPort);
        PrintFormat("4. Add daemon URL to MT5 allowed URLs:");
        PrintFormat("   Tools → Options → Expert Advisors → Allow WebRequest for URL:");
        PrintFormat("   %s", BuildDaemonUrl());
        PrintFormat("5. Check Windows Firewall settings");
        PrintFormat("6. Test daemon manually: curl -X GET %s", BuildDaemonUrl("health"));
        
        return false;
    }
}

string GetHttpConnectionStats()
{
    if(g_http_requests_sent == 0) return "No requests sent";
    
    double success_rate = (double)g_http_successful_responses / g_http_requests_sent * 100.0;
    return StringFormat("%d/%d (%.1f%%)", g_http_successful_responses, g_http_requests_sent, success_rate);
}

//+------------------------------------------------------------------+
//| KELLY CRITERION FUNCTIONS
//+------------------------------------------------------------------+
void InitializeKellySystem()
{
    ArrayResize(g_kelly_trade_history, 0);
    
    // Initialize Kelly metrics
    g_kelly_metrics.win_rate = 0.5;         // Start with 50% assumption
    g_kelly_metrics.avg_win_pips = 20.0;    // Conservative estimates
    g_kelly_metrics.avg_loss_pips = 15.0;
    g_kelly_metrics.avg_r_multiple = 1.33;
    g_kelly_metrics.profit_factor = 1.33;
    g_kelly_metrics.total_trades = 0;
    g_kelly_metrics.winning_trades = 0;
    g_kelly_metrics.kelly_fraction = BaseRiskWhenNoHistory / 100.0;
    g_kelly_metrics.confidence_adjusted_kelly = g_kelly_metrics.kelly_fraction;
    
    g_current_kelly_fraction = BaseRiskWhenNoHistory / 100.0;
    g_smoothed_kelly_fraction = g_current_kelly_fraction;
    
    LoadKellyTradeHistory(); // Load from file if exists
    
    PrintFormat("🎯 KELLY CRITERION INITIALIZED:");
    PrintFormat("   Enabled: %s", EnableKellyCriterion ? "YES" : "NO");
    PrintFormat("   Max Kelly Fraction: %.1f%%", MaxKellyFraction * 100);
    PrintFormat("   Kelly Multiplier: %.2f (Half-Kelly)", KellyMultiplier);
    PrintFormat("   Lookback Trades: %d", KellyLookbackTrades);
    PrintFormat("   Initial Kelly Fraction: %.2f%%", g_current_kelly_fraction * 100);
}

void LoadKellyTradeHistory()
{
    string filename = "kelly_trade_history.csv";
    
    if(!FileIsExist(filename, FILE_COMMON)) return;
    
    int file = FileOpen(filename, FILE_READ | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Skip header
    if(!FileIsEnding(file)) FileReadString(file);
    
    ArrayResize(g_kelly_trade_history, 0);
    
    while(!FileIsEnding(file) && ArraySize(g_kelly_trade_history) < KellyLookbackTrades * 2)
    {
        KellyTradeRecord record;
        record.trade_time = StringToTime(FileReadString(file));
        record.was_profitable = (FileReadNumber(file) > 0.5);
        record.profit_pips = FileReadNumber(file);
        record.loss_pips = FileReadNumber(file);
        record.r_multiple = FileReadNumber(file);
        record.confidence_used = FileReadNumber(file);
        record.trade_type = (ENUM_ORDER_TYPE)FileReadNumber(file);
        
        int size = ArraySize(g_kelly_trade_history);
        ArrayResize(g_kelly_trade_history, size + 1);
        g_kelly_trade_history[size] = record;
    }
    
    FileClose(file);
    
    if(ArraySize(g_kelly_trade_history) > 0)
    {
        CalculateKellyMetrics();
        PrintFormat("📊 Loaded %d Kelly trade records from history", ArraySize(g_kelly_trade_history));
    }
}

void SaveKellyTradeHistory()
{
    string filename = "kelly_trade_history.csv";
    
    int file = FileOpen(filename, FILE_WRITE | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Write header
    FileWrite(file, "TradeTime,WasProfitable,ProfitPips,LossPips,RMultiple,ConfidenceUsed,TradeType");
    
    // Keep only recent trades
    int start_idx = MathMax(0, ArraySize(g_kelly_trade_history) - KellyLookbackTrades * 2);
    
    for(int i = start_idx; i < ArraySize(g_kelly_trade_history); i++)
    {
        FileWrite(file, TimeToString(g_kelly_trade_history[i].trade_time),
                  g_kelly_trade_history[i].was_profitable ? 1 : 0,
                  g_kelly_trade_history[i].profit_pips,
                  g_kelly_trade_history[i].loss_pips,
                  g_kelly_trade_history[i].r_multiple,
                  g_kelly_trade_history[i].confidence_used,
                  (int)g_kelly_trade_history[i].trade_type);
    }
    
    FileClose(file);
}

void RecordKellyTrade(bool was_profitable, double profit_pips, double loss_pips, 
                      double confidence_used, ENUM_ORDER_TYPE trade_type)
{
    KellyTradeRecord new_record;
    new_record.trade_time = TimeCurrent();
    new_record.was_profitable = was_profitable;
    new_record.profit_pips = profit_pips;
    new_record.loss_pips = loss_pips;
    new_record.r_multiple = (loss_pips > 0) ? (profit_pips / loss_pips) : 0;
    new_record.confidence_used = confidence_used;
    new_record.trade_type = trade_type;
    
    // Add to history array
    int size = ArraySize(g_kelly_trade_history);
    ArrayResize(g_kelly_trade_history, size + 1);
    g_kelly_trade_history[size] = new_record;
    
    // Keep only recent trades
    if(ArraySize(g_kelly_trade_history) > KellyLookbackTrades * 2)
    {
        int excess = ArraySize(g_kelly_trade_history) - KellyLookbackTrades * 2;
        for(int i = 0; i < ArraySize(g_kelly_trade_history) - excess; i++)
            g_kelly_trade_history[i] = g_kelly_trade_history[i + excess];
        ArrayResize(g_kelly_trade_history, ArraySize(g_kelly_trade_history) - excess);
    }
    
    // Recalculate Kelly metrics
    CalculateKellyMetrics();
    SaveKellyTradeHistory();
    
    PrintFormat("📝 KELLY TRADE RECORDED: %s, %.1f pips, R=%.2f, New Kelly=%.2f%%", 
               was_profitable ? "WIN" : "LOSS", 
               was_profitable ? profit_pips : -loss_pips,
               new_record.r_multiple, g_current_kelly_fraction * 100);
}

void CalculateKellyMetrics()
{
    if(ArraySize(g_kelly_trade_history) < 5) 
    {
        // Not enough data, use conservative defaults
        g_kelly_metrics.win_rate = 0.5;
        g_kelly_metrics.avg_win_pips = 20.0;
        g_kelly_metrics.avg_loss_pips = 15.0;
        g_kelly_metrics.avg_r_multiple = 1.33;
        g_kelly_metrics.profit_factor = 1.33;
        g_kelly_metrics.total_trades = ArraySize(g_kelly_trade_history);
        g_kelly_metrics.winning_trades = 0;
        
        // Count actual wins for small sample
        for(int i = 0; i < ArraySize(g_kelly_trade_history); i++)
            if(g_kelly_trade_history[i].was_profitable) g_kelly_metrics.winning_trades++;
        
        g_kelly_metrics.kelly_fraction = BaseRiskWhenNoHistory / 100.0;
        g_current_kelly_fraction = g_kelly_metrics.kelly_fraction;
        return;
    }
    
    // Use recent trades for calculation
    int analyze_count = MathMin(ArraySize(g_kelly_trade_history), KellyLookbackTrades);
    int start_idx = ArraySize(g_kelly_trade_history) - analyze_count;
    
    // Calculate win rate and averages
    int wins = 0;
    double total_win_pips = 0, total_loss_pips = 0;
    double total_win_r = 0, total_loss_r = 0;
    int win_count = 0, loss_count = 0;
    
    for(int i = start_idx; i < ArraySize(g_kelly_trade_history); i++)
    {
        if(g_kelly_trade_history[i].was_profitable)
        {
            wins++;
            win_count++;
            total_win_pips += g_kelly_trade_history[i].profit_pips;
            total_win_r += g_kelly_trade_history[i].r_multiple;
        }
        else
        {
            loss_count++;
            total_loss_pips += g_kelly_trade_history[i].loss_pips;
        }
    }
    
    g_kelly_metrics.total_trades = analyze_count;
    g_kelly_metrics.winning_trades = wins;
    g_kelly_metrics.win_rate = (double)wins / analyze_count;
    
    g_kelly_metrics.avg_win_pips = (win_count > 0) ? total_win_pips / win_count : 20.0;
    g_kelly_metrics.avg_loss_pips = (loss_count > 0) ? total_loss_pips / loss_count : 15.0;
    g_kelly_metrics.avg_r_multiple = (win_count > 0) ? total_win_r / win_count : 1.0;
    
    // Calculate profit factor
    g_kelly_metrics.profit_factor = (total_loss_pips > 0) ? total_win_pips / total_loss_pips : 1.0;
    
    // Calculate Kelly fraction using the standard formula
    // Kelly% = (Win_Rate * Avg_R_Multiple - Loss_Rate) / Avg_R_Multiple
    double loss_rate = 1.0 - g_kelly_metrics.win_rate;
    double avg_r = g_kelly_metrics.avg_r_multiple;
    
    if(avg_r > 0)
    {
        g_kelly_metrics.kelly_fraction = (g_kelly_metrics.win_rate * avg_r - loss_rate) / avg_r;
    }
    else
    {
        g_kelly_metrics.kelly_fraction = 0.02; // Fallback
    }
    
    // Apply Kelly multiplier (Half-Kelly is common)
    g_kelly_metrics.kelly_fraction *= KellyMultiplier;
    
    // Apply bounds
    g_kelly_metrics.kelly_fraction = MathMax(MinKellyFraction, 
                                            MathMin(MaxKellyFraction, g_kelly_metrics.kelly_fraction));
    
    // Store raw calculation
    g_last_calculated_kelly = g_kelly_metrics.kelly_fraction;
    
    // Apply smoothing if enabled
    if(EnableKellySmoothing && g_current_kelly_fraction > 0)
    {
        g_smoothed_kelly_fraction = g_current_kelly_fraction * (1.0 - KellySmoothingFactor) + 
                                   g_kelly_metrics.kelly_fraction * KellySmoothingFactor;
    }
    else
    {
        g_smoothed_kelly_fraction = g_kelly_metrics.kelly_fraction;
    }
    
    g_current_kelly_fraction = g_smoothed_kelly_fraction;
    g_last_kelly_update = TimeCurrent();
    
    PrintFormat("📊 KELLY METRICS UPDATE (%d trades):", analyze_count);
    PrintFormat("   Win Rate: %.1f%% (%d/%d)", g_kelly_metrics.win_rate * 100, wins, analyze_count);
    PrintFormat("   Avg Win: %.1f pips | Avg Loss: %.1f pips", 
               g_kelly_metrics.avg_win_pips, g_kelly_metrics.avg_loss_pips);
    PrintFormat("   Avg R-Multiple: %.2f | Profit Factor: %.2f", 
               g_kelly_metrics.avg_r_multiple, g_kelly_metrics.profit_factor);
    PrintFormat("   Raw Kelly: %.2f%% | Smoothed Kelly: %.2f%%", 
               g_kelly_metrics.kelly_fraction * 100, g_current_kelly_fraction * 100);
}

double GetConfidenceAdjustedKelly(double prediction_confidence)
{
    if(!UseConfidenceScaling) return g_current_kelly_fraction;
    
    // Scale Kelly fraction by prediction confidence
    // Higher confidence = larger position, lower confidence = smaller position
    double confidence_multiplier = prediction_confidence / 0.5; // 0.5 = neutral confidence
    confidence_multiplier = MathMax(0.3, MathMin(2.0, confidence_multiplier)); // Bounds
    
    double adjusted_kelly = g_current_kelly_fraction * confidence_multiplier;
    
    // Apply final bounds
    adjusted_kelly = MathMax(MinKellyFraction, MathMin(MaxKellyFraction, adjusted_kelly));
    
    g_kelly_metrics.confidence_adjusted_kelly = adjusted_kelly;
    
    return adjusted_kelly;
}

//+------------------------------------------------------------------+
//| STRATEGY TESTER LEARNING FUNCTIONS
//+------------------------------------------------------------------+
void InitializeTesterLearning()
{
    g_is_tester_mode = MQLInfoInteger(MQL_TESTER);
    if(g_is_tester_mode)
    {
        g_tester_start_balance = AccountInfoDouble(ACCOUNT_BALANCE);
        g_max_equity_peak = g_tester_start_balance;
        PrintFormat("🧪 Strategy Tester Learning Mode - Start Balance: %.2f", g_tester_start_balance);
    }
    
    LoadTesterResults();
}

void LoadTesterResults()
{
    if(!EnableTesterLearning || !FileIsExist(TESTER_RESULTS_FILE, FILE_COMMON)) return;
    
    int file = FileOpen(TESTER_RESULTS_FILE, FILE_READ | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Skip header
    if(!FileIsEnding(file)) FileReadString(file);
    
    ArrayResize(g_tester_results, 0);
    while(!FileIsEnding(file))
    {
        TesterResult result;
        result.test_date = StringToTime(FileReadString(file));
        result.symbol = FileReadString(file);
        result.timeframe = FileReadString(file);
        result.total_profit = FileReadNumber(file);
        result.max_drawdown = FileReadNumber(file);
        result.total_trades = (int)FileReadNumber(file);
        result.success_rate = FileReadNumber(file);
        result.sharpe_ratio = FileReadNumber(file);
        result.best_confidence_threshold = FileReadNumber(file);
        result.best_risk_multiplier = FileReadNumber(file);
        
        for(int i = 0; i < PREDICTION_STEPS; i++)
            result.avg_step_weight[i] = FileReadNumber(file);
        
        result.market_conditions_score = FileReadNumber(file);
        
        int size = ArraySize(g_tester_results);
        ArrayResize(g_tester_results, size + 1);
        g_tester_results[size] = result;
    }
    
    FileClose(file);
    PrintFormat("📊 Loaded %d tester results for learning", ArraySize(g_tester_results));
}

void SaveTesterResults()
{
    if(!EnableTesterLearning) return;
    
    int file = FileOpen(TESTER_RESULTS_FILE, FILE_WRITE | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Write header
    string header = "TestDate,Symbol,Timeframe,TotalProfit,MaxDrawdown,TotalTrades,SuccessRate,SharpeRatio,BestConfidence,BestRiskMultiplier";
    for(int i = 0; i < PREDICTION_STEPS; i++)
        header += ",StepWeight" + IntegerToString(i);
    header += ",MarketConditionsScore";
    FileWrite(file, header);
    
    for(int i = 0; i < ArraySize(g_tester_results); i++)
    {
        string line = TimeToString(g_tester_results[i].test_date) + "," +
                     g_tester_results[i].symbol + "," +
                     g_tester_results[i].timeframe + "," +
                     DoubleToString(g_tester_results[i].total_profit, 2) + "," +
                     DoubleToString(g_tester_results[i].max_drawdown, 2) + "," +
                     IntegerToString(g_tester_results[i].total_trades) + "," +
                     DoubleToString(g_tester_results[i].success_rate, 3) + "," +
                     DoubleToString(g_tester_results[i].sharpe_ratio, 3) + "," +
                     DoubleToString(g_tester_results[i].best_confidence_threshold, 3) + "," +
                     DoubleToString(g_tester_results[i].best_risk_multiplier, 3);
        
        for(int j = 0; j < PREDICTION_STEPS; j++)
            line += "," + DoubleToString(g_tester_results[i].avg_step_weight[j], 3);
        
        line += "," + DoubleToString(g_tester_results[i].market_conditions_score, 3);
        
        FileWrite(file, line);
    }
    
    FileClose(file);
}

void RecordTesterResult()
{
    if(!g_is_tester_mode || !EnableTesterLearning) return;
    
    // Calculate test results
    HistorySelect(0, TimeCurrent());
    int total_deals = HistoryDealsTotal();
    double total_profit = 0;
    int profitable_trades = 0;
    int total_trades = 0;
    double max_dd = 0;
    
    for(int i = 0; i < total_deals; i++)
    {
        ulong ticket = HistoryDealGetTicket(i);
        if(ticket > 0 && HistoryDealGetString(ticket, DEAL_SYMBOL) == _Symbol &&
           HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
        {
            double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
            total_profit += profit;
            total_trades++;
            if(profit > 0) profitable_trades++;
        }
    }
    
    // Calculate Sharpe ratio
    double profits[];
    ArrayResize(profits, total_trades);
    int profit_idx = 0;
    
    for(int i = 0; i < total_deals; i++)
    {
        ulong ticket = HistoryDealGetTicket(i);
        if(ticket > 0 && HistoryDealGetString(ticket, DEAL_SYMBOL) == _Symbol &&
           HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
        {
            profits[profit_idx++] = HistoryDealGetDouble(ticket, DEAL_PROFIT);
        }
    }
    
    double sharpe = 0;
    if(total_trades > 1)
    {
        double mean_profit = MathMean(profits);
        double std_dev = MathStandardDeviation(profits);
        if(std_dev > 0) sharpe = mean_profit / std_dev;
    }
    
    // Create tester result record
    TesterResult result;
    result.test_date = TimeCurrent();
    result.symbol = _Symbol;
    result.timeframe = "H1";
    result.total_profit = total_profit;
    result.max_drawdown = g_current_drawdown;
    result.total_trades = total_trades;
    result.success_rate = (total_trades > 0) ? (double)profitable_trades / total_trades * 100.0 : 0;
    result.sharpe_ratio = sharpe;
    result.best_confidence_threshold = g_adaptive_metrics.dynamic_confidence_threshold;
    result.best_risk_multiplier = g_adaptive_metrics.dynamic_risk_multiplier;
    
    for(int i = 0; i < PREDICTION_STEPS; i++)
        result.avg_step_weight[i] = g_adaptive_metrics.step_weights[i];
    
    result.market_conditions_score = CalculateMarketConditionScore();
    
    // Add to results array
    int size = ArraySize(g_tester_results);
    ArrayResize(g_tester_results, size + 1);
    g_tester_results[size] = result;
    
    PrintFormat("🧪 Tester Result Recorded: Profit=%.2f, Trades=%d, Success=%.1f%%, Sharpe=%.3f", 
               total_profit, total_trades, result.success_rate, sharpe);
}

double CalculateMarketConditionScore()
{
    double volatility_score = MathMin(2.0, g_current_market_condition.volatility_level);
    double trend_score = MathAbs(g_current_market_condition.trend_direction);
    double accuracy_score = g_current_market_condition.recent_accuracy / 100.0;
    
    return (volatility_score * 0.3 + trend_score * 0.3 + accuracy_score * 0.4);
}

void ApplyTesterLearning()
{
    if(!EnableTesterLearning || ArraySize(g_tester_results) < 3) return;
    
    // Find best performing configurations from tester results
    double best_profit = -999999;
    double best_sharpe = -999999;
    TesterResult best_profit_result, best_sharpe_result;
    
    for(int i = 0; i < ArraySize(g_tester_results); i++)
    {
        if(g_tester_results[i].symbol == _Symbol)
        {
            if(g_tester_results[i].total_profit > best_profit)
            {
                best_profit = g_tester_results[i].total_profit;
                best_profit_result = g_tester_results[i];
            }
            
            if(g_tester_results[i].sharpe_ratio > best_sharpe)
            {
                best_sharpe = g_tester_results[i].sharpe_ratio;
                best_sharpe_result = g_tester_results[i];
            }
        }
    }
    
    if(best_profit > -999999 && best_sharpe > -999999)
    {
        // Blend best profit and best sharpe configurations
        double profit_weight = TesterLearningWeight;
        double sharpe_weight = 1.0 - TesterLearningWeight;
        
        double learned_confidence = best_profit_result.best_confidence_threshold * profit_weight + 
                                   best_sharpe_result.best_confidence_threshold * sharpe_weight;
        
        double learned_risk = best_profit_result.best_risk_multiplier * profit_weight + 
                             best_sharpe_result.best_risk_multiplier * sharpe_weight;
        
        // Apply learned parameters with current adaptive adjustments
        g_adaptive_metrics.dynamic_confidence_threshold = MathMax(0.20, MathMin(0.85, learned_confidence));
        g_adaptive_metrics.dynamic_risk_multiplier = MathMax(0.3, MathMin(2.5, learned_risk));
        
        // Blend step weights
        for(int i = 0; i < PREDICTION_STEPS; i++)
        {
            double learned_weight = best_profit_result.avg_step_weight[i] * profit_weight + 
                                   best_sharpe_result.avg_step_weight[i] * sharpe_weight;
            g_adaptive_metrics.step_weights[i] = MathMax(0.1, MathMin(3.0, learned_weight));
        }
        
        PrintFormat("🧪 Applied Tester Learning: Conf=%.3f, Risk=%.2fx from %d results", 
                   learned_confidence, learned_risk, ArraySize(g_tester_results));
    }
}

//+------------------------------------------------------------------+
//| IMPROVED POSITION IDENTIFICATION FUNCTIONS - FIXED
//+------------------------------------------------------------------+
bool IsScalpingPosition()
{
    // This function more reliably identifies a scalping position
    // to prevent main strategy logic from interfering with it.
    if(!g_scalping_position.is_active || !PositionSelect(_Symbol))
        return false;
        
    datetime pos_time = (datetime)PositionGetInteger(POSITION_TIME);
    double pos_entry = PositionGetDouble(POSITION_PRICE_OPEN);
    string pos_comment = PositionGetString(POSITION_COMMENT);
    
    // Primary check: comment. This is the fastest and most reliable.
    if(StringFind(pos_comment, "ScalpTP") >= 0)
    {
        return true;
    }
    
    // Secondary check as a fallback: time and price match
    bool time_match = MathAbs((long)(pos_time - g_scalping_position.entry_time)) <= 180; // 3 minutes tolerance
    bool price_match = MathAbs(pos_entry - g_scalping_position.entry_price) <= _Point * 5; // 5 points tolerance
    
    // A scalping position is identified if the comment matches OR if both time and price match closely.
    return (time_match && price_match);
}

//+------------------------------------------------------------------+
//| FIXED SCALPING POSITION MANAGEMENT
//+------------------------------------------------------------------+
void ManageScalpingPosition()
{
    if(!EnableScalpingStrategy || !g_scalping_position.is_active) return;
    
    // First, check if the position still exists
    if(!PositionSelect(_Symbol) || !IsScalpingPosition())
    {
        // The position was likely closed by TP or manually. Reset the state.
        if(g_scalping_position.ticket != 0)
        {
           PrintFormat("📈 SCALPING POSITION (Ticket %d) was closed.", g_scalping_position.ticket);
           // NOTE: Trade recording is handled in OnTick's deal history check for robustness
           g_scalping_position.is_active = false;
           g_scalping_position.ticket = 0;
        }
        return;
    }
    
    // FIXED: Switch to a reliable bar-based timeout instead of time-based.
    // This prevents premature closing on weekends or market holidays.
    datetime entry_bar_time = iTime(_Symbol, PERIOD_H1, iBarShift(_Symbol, PERIOD_H1, g_scalping_position.entry_time));
    datetime current_bar_time = iTime(_Symbol, PERIOD_H1, 0);
    
    if(entry_bar_time == 0 || current_bar_time == 0) return; // Not enough history
    
    int bars_elapsed = (int)((current_bar_time - entry_bar_time) / PeriodSeconds(PERIOD_H1));

    static datetime last_log_time = 0;
    if(TimeCurrent() - last_log_time > 60) // Log status every minute
    {
        PrintFormat("🔍 SCALPING TIMEOUT CHECK: Bars elapsed=%d, Timeout set for %d bars", bars_elapsed, ScalpingTimeoutBars);
        last_log_time = TimeCurrent();
    }
        
    // Check timeout condition
    if(bars_elapsed >= ScalpingTimeoutBars)
    {
        PrintFormat("⏰ SCALPING TIMEOUT: Closing position after %d bars (limit was %d).", bars_elapsed, ScalpingTimeoutBars);
        
        if(trade.PositionClose(_Symbol))
        {
            PrintFormat("✅ SCALPING POSITION CLOSED BY TIMEOUT.");
            // Reset state. Trade recording is handled by OnTick's deal check.
            g_scalping_position.is_active = false;
        }
        else
        {
            PrintFormat("❌ FAILED TO CLOSE SCALPING POSITION by timeout: %s (Code: %d)", trade.ResultComment(), trade.ResultRetcode());
        }
    }
}

double CalculateWeightedSignalStrength(const double &response_prices[], double current_price)
{
    if(!EnableStepWeighting || AdaptiveLearningMode == ADAPTIVE_DISABLED)
    {
        // Original logic - count steps
        int bullish_steps = 0;
        for(int i = 0; i < PREDICTION_STEPS; i++)
            if(response_prices[i] > current_price) bullish_steps++;
        return (double)bullish_steps / PREDICTION_STEPS;
    }
    
    // Weighted signal strength
    double weighted_signal = 0;
    double total_weights = 0;
    
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        double step_weight = GetStepWeight(i);
        double step_signal = (response_prices[i] > current_price) ? 1.0 : 0.0;
        
        weighted_signal += step_signal * step_weight;
        total_weights += step_weight;
    }
    
    return (total_weights > 0) ? weighted_signal / total_weights : 0.5;
}

//+------------------------------------------------------------------+
//| ADAPTIVE LEARNING FUNCTIONS
//+------------------------------------------------------------------+
void InitializeAdaptiveLearning()
{
    ArrayResize(g_trade_history, 0);
    
    // Initialize adaptive metrics with defaults
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        g_adaptive_metrics.avg_accuracy[i] = 50.0;
        g_adaptive_metrics.step_weights[i] = 1.0;
    }
    
    g_adaptive_metrics.dynamic_confidence_threshold = MinimumModelConfidence;
    g_adaptive_metrics.dynamic_risk_multiplier = 1.0;
    g_adaptive_metrics.success_rate_last_n_trades = 50.0;
    g_adaptive_metrics.avg_profit_per_trade = 0.0;
    g_adaptive_metrics.volatility_factor = 1.0;
    g_adaptive_metrics.trades_analyzed = 0;
    g_adaptive_metrics.max_drawdown_experienced = 0;
    g_adaptive_metrics.best_performing_step = 0;
    g_adaptive_metrics.worst_performing_step = 0;
    
    LoadAdaptiveLearningData();
    InitializeTesterLearning();
    InitializeScalpingStrategy();  // Initialize scalping strategy
    InitializeTradingHours();       // Initialize trading hours
    ApplyTesterLearning(); // Apply any previous tester learning
    
    g_adaptive_system_initialized = true;
    
    PrintFormat("🧠 Adaptive Learning System Initialized - Mode: %s, Tester Learning: %s, Scalping: %s, Trading Hours: %s", 
               AdaptiveLearningMode == ADAPTIVE_DISABLED ? "DISABLED" :
               AdaptiveLearningMode == ADAPTIVE_CONSERVATIVE ? "CONSERVATIVE" : "AGGRESSIVE",
               EnableTesterLearning ? "ENABLED" : "DISABLED",
               EnableScalpingStrategy ? "ENABLED" : "DISABLED",
               EnableTradingHours ? "ENABLED" : "DISABLED");
}

void LoadAdaptiveLearningData()
{
    if(!FileIsExist(ADAPTIVE_LEARNING_FILE, FILE_COMMON)) return;
    
    int file = FileOpen(ADAPTIVE_LEARNING_FILE, FILE_READ | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Skip header
    if(!FileIsEnding(file)) FileReadString(file);
    
    while(!FileIsEnding(file) && ArraySize(g_trade_history) < AdaptiveLearningPeriod * 2)
    {
        TradeRecord trade_rec;
        trade_rec.trade_time = StringToTime(FileReadString(file));
        trade_rec.entry_price = FileReadNumber(file);
        trade_rec.exit_price = FileReadNumber(file);
        trade_rec.profit = FileReadNumber(file);
        trade_rec.confidence_used = FileReadNumber(file);
        trade_rec.risk_used = FileReadNumber(file);
        trade_rec.prediction_step_used = (int)FileReadNumber(file);
        trade_rec.accuracy_at_trade = FileReadNumber(file);
        trade_rec.was_profitable = (FileReadNumber(file) > 0.5);
        trade_rec.market_volatility = FileReadNumber(file);
        trade_rec.hour_of_day = (int)FileReadNumber(file);
        trade_rec.drawdown_at_entry = FileReadNumber(file);
        trade_rec.prediction_error = FileReadNumber(file);
        trade_rec.from_tester = (FileReadNumber(file) > 0.5);
        
        int size = ArraySize(g_trade_history);
        ArrayResize(g_trade_history, size + 1);
        g_trade_history[size] = trade_rec;
    }
    
    FileClose(file);
    PrintFormat("📊 Loaded %d historical trades for adaptive learning", ArraySize(g_trade_history));
}

void SaveAdaptiveLearningData()
{
    int file = FileOpen(ADAPTIVE_LEARNING_FILE, FILE_WRITE | FILE_CSV | FILE_COMMON);
    if(file == INVALID_HANDLE) return;
    
    // Write header
    FileWrite(file, "TradeTime,EntryPrice,ExitPrice,Profit,ConfidenceUsed,RiskUsed,PredictionStep,AccuracyAtTrade,WasProfitable,MarketVolatility,HourOfDay,DrawdownAtEntry,PredictionError,FromTester");
    
    int start_idx = MathMax(0, ArraySize(g_trade_history) - AdaptiveLearningPeriod * 2);
    for(int i = start_idx; i < ArraySize(g_trade_history); i++)
    {
        FileWrite(file, TimeToString(g_trade_history[i].trade_time),
                  g_trade_history[i].entry_price, g_trade_history[i].exit_price,
                  g_trade_history[i].profit, g_trade_history[i].confidence_used,
                  g_trade_history[i].risk_used, g_trade_history[i].prediction_step_used,
                  g_trade_history[i].accuracy_at_trade, g_trade_history[i].was_profitable ? 1 : 0,
                  g_trade_history[i].market_volatility, g_trade_history[i].hour_of_day,
                  g_trade_history[i].drawdown_at_entry, g_trade_history[i].prediction_error,
                  g_trade_history[i].from_tester ? 1 : 0);
    }
    
    FileClose(file);
}

void RecordTrade(double entry_price, double exit_price, double profit, double confidence_used, double risk_used, int step_used)
{
    if(AdaptiveLearningMode == ADAPTIVE_DISABLED) return;
    
    TradeRecord new_trade;
    new_trade.trade_time = TimeCurrent();
    new_trade.entry_price = entry_price;
    new_trade.exit_price = exit_price;
    new_trade.profit = profit;
    new_trade.confidence_used = confidence_used;
    new_trade.risk_used = risk_used;
    new_trade.prediction_step_used = step_used;
    new_trade.was_profitable = (profit > 0);
    new_trade.from_tester = g_is_tester_mode;
    new_trade.drawdown_at_entry = g_current_drawdown;
    
    // Calculate accuracy at trade time
    new_trade.accuracy_at_trade = 0;
    if(step_used >= 0 && step_used < PREDICTION_STEPS && g_total_predictions[step_used] > 0)
        new_trade.accuracy_at_trade = g_accuracy_pct[step_used];
    
    // Calculate prediction error
    if(step_used >= 0 && step_used < PREDICTION_STEPS && g_last_predictions[step_used] > 0)
        new_trade.prediction_error = MathAbs(exit_price - g_last_predictions[step_used]) / g_last_predictions[step_used];
    else
        new_trade.prediction_error = 0;
    
    // Calculate market volatility
    double atr_val[];
    if(CopyBuffer(atr_handle, 0, 1, 1, atr_val) > 0)
        new_trade.market_volatility = atr_val[0];
    else
        new_trade.market_volatility = 0.001;
    
    MqlDateTime dt;
    TimeToStruct(new_trade.trade_time, dt);
    new_trade.hour_of_day = dt.hour;
    
    int size = ArraySize(g_trade_history);
    ArrayResize(g_trade_history, size + 1);
    g_trade_history[size] = new_trade;
    
    // Keep only recent trades
    if(ArraySize(g_trade_history) > AdaptiveLearningPeriod * 2)
    {
        int excess = ArraySize(g_trade_history) - AdaptiveLearningPeriod * 2;
        for(int i = 0; i < ArraySize(g_trade_history) - excess; i++)
            g_trade_history[i] = g_trade_history[i + excess];
        ArrayResize(g_trade_history, ArraySize(g_trade_history) - excess);
    }
    
    // Calculate pip values for Kelly tracking
    double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
    double pip_difference = MathAbs(exit_price - entry_price) / pip_size;
    bool was_profitable = (profit > 0);
    double profit_pips = was_profitable ? pip_difference : 0;
    double loss_pips = was_profitable ? 0 : pip_difference;
    ENUM_ORDER_TYPE trade_type = (exit_price > entry_price) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
    
    // Record for Kelly Criterion
    RecordKellyTrade(was_profitable, profit_pips, loss_pips, confidence_used, trade_type);
    
    PrintFormat("📝 Recorded trade: P&L=%.2f, Confidence=%.3f, Step=%d, Accuracy=%.1f%%, Error=%.4f, Tester=%s", 
               profit, confidence_used, step_used, new_trade.accuracy_at_trade, new_trade.prediction_error,
               new_trade.from_tester ? "YES" : "NO");
}

void UpdateCurrentMarketCondition()
{
    // Calculate volatility
    double atr_val[];
    if(CopyBuffer(atr_handle, 0, 1, 20, atr_val) >= 20)
    {
        double current_atr = atr_val[0];
        double avg_atr = 0;
        for(int i = 0; i < 20; i++) avg_atr += atr_val[i];
        avg_atr /= 20;
        
        g_current_market_condition.volatility_level = current_atr / avg_atr;
    }
    else
    {
        g_current_market_condition.volatility_level = 1.0;
    }
    
    // Determine trend direction
    double ma_fast[], ma_slow[];
    int ma_fast_handle = iMA(_Symbol, PERIOD_H1, 10, 0, MODE_EMA, PRICE_CLOSE);
    int ma_slow_handle = iMA(_Symbol, PERIOD_H1, 30, 0, MODE_EMA, PRICE_CLOSE);
    
    if(CopyBuffer(ma_fast_handle, 0, 1, 1, ma_fast) > 0 && 
       CopyBuffer(ma_slow_handle, 0, 1, 1, ma_slow) > 0)
    {
        if(ma_fast[0] > ma_slow[0] * 1.001) g_current_market_condition.trend_direction = 1;
        else if(ma_fast[0] < ma_slow[0] * 0.999) g_current_market_condition.trend_direction = -1;
        else g_current_market_condition.trend_direction = 0;
    }
    
    IndicatorRelease(ma_fast_handle);
    IndicatorRelease(ma_slow_handle);
    
    // Set session hour
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    g_current_market_condition.session_hour = dt.hour;
    
    // Calculate recent accuracy
    double total_accuracy = 0;
    int valid_steps = 0;
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        if(g_total_predictions[i] > 5)
        {
            total_accuracy += g_accuracy_pct[i];
            valid_steps++;
        }
    }
    g_current_market_condition.recent_accuracy = (valid_steps > 0) ? total_accuracy / valid_steps : 50.0;
    
    // Update drawdown tracking
    double current_equity = AccountInfoDouble(ACCOUNT_EQUITY);
    if(current_equity > g_max_equity_peak)
        g_max_equity_peak = current_equity;
    
    g_current_drawdown = (g_max_equity_peak > 0) ? (g_max_equity_peak - current_equity) / g_max_equity_peak * 100.0 : 0.0;
    if(g_current_drawdown > g_adaptive_metrics.max_drawdown_experienced)
        g_adaptive_metrics.max_drawdown_experienced = g_current_drawdown;
}

void PerformAdaptiveLearning()
{
    if(AdaptiveLearningMode == ADAPTIVE_DISABLED || 
       ArraySize(g_trade_history) < MinTradesForAdaptation) return;
    
    UpdateCurrentMarketCondition();
    
    int analyze_count = MathMin(ArraySize(g_trade_history), AdaptiveLearningPeriod);
    int start_idx = ArraySize(g_trade_history) - analyze_count;
    
    // Calculate step-specific accuracies and performance
    double step_profits[PREDICTION_STEPS];
    int step_trades[PREDICTION_STEPS];
    int step_wins[PREDICTION_STEPS];
    double step_errors[PREDICTION_STEPS];
    
    ArrayInitialize(step_profits, 0);
    ArrayInitialize(step_trades, 0);
    ArrayInitialize(step_wins, 0);
    ArrayInitialize(step_errors, 0);
    
    for(int step = 0; step < PREDICTION_STEPS; step++)
    {
        for(int i = start_idx; i < ArraySize(g_trade_history); i++)
        {
            if(g_trade_history[i].prediction_step_used == step)
            {
                step_profits[step] += g_trade_history[i].profit;
                step_trades[step]++;
                if(g_trade_history[i].was_profitable) step_wins[step]++;
                step_errors[step] += g_trade_history[i].prediction_error;
            }
        }
        
        if(step_trades[step] > 2)
        {
            g_adaptive_metrics.avg_accuracy[step] = (double)step_wins[step] / step_trades[step] * 100.0;
            
            // Calculate step weight based on multiple factors
            double step_profit_factor = (step_trades[step] > 0) ? (step_profits[step] / step_trades[step]) : 0;
            double step_accuracy_factor = g_adaptive_metrics.avg_accuracy[step] / 50.0;
            double step_error_factor = (step_trades[step] > 0) ? (1.0 / (1.0 + step_errors[step] / step_trades[step])) : 0.5;
            
            g_adaptive_metrics.step_weights[step] = MathMax(0.1, MathMin(3.0, 
                (step_profit_factor * 0.4 + step_accuracy_factor * 0.4 + step_error_factor * 0.2)));
        }
    }
    
    // Find best and worst performing steps
    double best_weight = 0, worst_weight = 999;
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        if(g_adaptive_metrics.step_weights[i] > best_weight)
        {
            best_weight = g_adaptive_metrics.step_weights[i];
            g_adaptive_metrics.best_performing_step = i;
        }
        if(g_adaptive_metrics.step_weights[i] < worst_weight)
        {
            worst_weight = g_adaptive_metrics.step_weights[i];
            g_adaptive_metrics.worst_performing_step = i;
        }
    }
    
    // Calculate overall success metrics
    double total_profit = 0;
    int winning_trades = 0;
    double volatility_sum = 0;
    
    for(int i = start_idx; i < ArraySize(g_trade_history); i++)
    {
        total_profit += g_trade_history[i].profit;
        if(g_trade_history[i].was_profitable) winning_trades++;
        volatility_sum += g_trade_history[i].market_volatility;
    }
    
    g_adaptive_metrics.success_rate_last_n_trades = (double)winning_trades / analyze_count * 100.0;
    g_adaptive_metrics.avg_profit_per_trade = total_profit / analyze_count;
    g_adaptive_metrics.volatility_factor = volatility_sum / analyze_count;
    g_adaptive_metrics.trades_analyzed = analyze_count;
    
    // Adapt confidence threshold
    if(EnableDynamicConfidence)
    {
        double confidence_adjustment = 0;
        
        if(g_adaptive_metrics.success_rate_last_n_trades > 65.0)
        {
            confidence_adjustment = -AdaptiveConfidenceRange * 0.3;
        }
        else if(g_adaptive_metrics.success_rate_last_n_trades < 45.0)
        {
            confidence_adjustment = AdaptiveConfidenceRange * 0.4;
        }
        
        // Apply market condition adjustments
        if(EnableMarketConditionAdaptation)
        {
            if(g_current_market_condition.volatility_level > 1.5)
                confidence_adjustment += AdaptiveConfidenceRange * 0.2;
            if(g_current_market_condition.recent_accuracy < 40.0)
                confidence_adjustment += AdaptiveConfidenceRange * 0.3;
            if(g_current_drawdown > 15.0)
                confidence_adjustment += AdaptiveConfidenceRange * 0.25;
        }
        
        // Apply adaptive mode scaling
        if(AdaptiveLearningMode == ADAPTIVE_CONSERVATIVE)
            confidence_adjustment *= 0.5;
        else if(AdaptiveLearningMode == ADAPTIVE_AGGRESSIVE)
            confidence_adjustment *= 1.5;
        
        g_adaptive_metrics.dynamic_confidence_threshold = MathMax(0.20, MathMin(0.85, 
            MinimumModelConfidence + confidence_adjustment));
    }
    
    // Adapt risk multiplier
    if(EnableAdaptivePositionSizing)
    {
        double risk_adjustment = 0;
        
        if(g_adaptive_metrics.success_rate_last_n_trades > 60.0 && g_adaptive_metrics.avg_profit_per_trade > 0)
        {
            risk_adjustment = AdaptiveRiskRange * 0.3;
        }
        else if(g_adaptive_metrics.success_rate_last_n_trades < 40.0 || g_adaptive_metrics.avg_profit_per_trade < 0)
        {
            risk_adjustment = -AdaptiveRiskRange * 0.4;
        }
        
        // Market condition adjustments
        if(EnableMarketConditionAdaptation)
        {
            if(g_current_market_condition.volatility_level > 1.3)
                risk_adjustment -= AdaptiveRiskRange * 0.2;
            if(g_current_drawdown > 20.0)
                risk_adjustment -= AdaptiveRiskRange * 0.3;
        }
        
        // Apply adaptive mode scaling
        if(AdaptiveLearningMode == ADAPTIVE_CONSERVATIVE)
            risk_adjustment *= 0.6;
        else if(AdaptiveLearningMode == ADAPTIVE_AGGRESSIVE)
            risk_adjustment *= 1.3;
        
        g_adaptive_metrics.dynamic_risk_multiplier = MathMax(0.3, MathMin(2.5, 1.0 + risk_adjustment));
    }
    
    g_last_adaptation_time = TimeCurrent();
    
    PrintFormat("🧠 ADAPTIVE LEARNING UPDATE:");
    PrintFormat("   Success Rate: %.1f%% | Avg Profit: %.2f | Drawdown: %.1f%%", 
               g_adaptive_metrics.success_rate_last_n_trades, g_adaptive_metrics.avg_profit_per_trade, g_current_drawdown);
    PrintFormat("   Dynamic Confidence: %.3f (vs %.3f original)", 
               g_adaptive_metrics.dynamic_confidence_threshold, MinimumModelConfidence);
    PrintFormat("   Dynamic Risk Multiplier: %.2f", g_adaptive_metrics.dynamic_risk_multiplier);
    PrintFormat("   Best Step: H+%d (%.2f) | Worst Step: H+%d (%.2f)", 
               (int)g_adaptive_metrics.best_performing_step + 1, best_weight,
               (int)g_adaptive_metrics.worst_performing_step + 1, worst_weight);
    
    SaveAdaptiveLearningData();
}

double GetAdaptiveConfidenceThreshold()
{
    if(!EnableDynamicConfidence || AdaptiveLearningMode == ADAPTIVE_DISABLED)
        return MinimumModelConfidence;
    return g_adaptive_metrics.dynamic_confidence_threshold;
}

double GetAdaptiveRiskMultiplier()
{
    if(!EnableAdaptivePositionSizing || AdaptiveLearningMode == ADAPTIVE_DISABLED)
        return 1.0;
    return g_adaptive_metrics.dynamic_risk_multiplier;
}

double GetStepWeight(int step)
{
    if(!EnableStepWeighting || AdaptiveLearningMode == ADAPTIVE_DISABLED || 
       step < 0 || step >= PREDICTION_STEPS)
        return 1.0;
    return g_adaptive_metrics.step_weights[step];
}

//+------------------------------------------------------------------+
//| SCALPING STRATEGY FUNCTIONS
//+------------------------------------------------------------------+
void InitializeScalpingStrategy()
{
    g_scalping_position.is_active = false;
    g_scalping_position.entry_time = 0;
    g_scalping_position.entry_price = 0;
    g_scalping_position.target_price = 0;
    g_scalping_position.target_step = -1;
    g_scalping_position.order_type = ORDER_TYPE_BUY;
    g_scalping_position.lot_size = 0;
    g_scalping_position.ticket = 0;
    g_scalping_position.timeout_time = 0;
    g_scalping_position.comment = "";
    
    PrintFormat("📈 SCALPING STRATEGY INITIALIZATION:");
    PrintFormat("   Status: %s", EnableScalpingStrategy ? "ENABLED" : "DISABLED");
    
    if(EnableScalpingStrategy)
    {
        // ENHANCED VALIDATION AND WARNINGS
        if(ScalpingTimeoutBars <= 0)
        {
            PrintFormat("   ⚠️  WARNING: ScalpingTimeoutBars (%d) should be > 0", ScalpingTimeoutBars);
        }
        
        if(EnableTimeBasedExit && MaxPositionHoldBars <= ScalpingTimeoutBars)
        {
            PrintFormat("   ⚠️  WARNING: MaxPositionHoldBars (%d) <= ScalpingTimeoutBars (%d)", 
                       MaxPositionHoldBars, ScalpingTimeoutBars);
            PrintFormat("           This may cause main strategy to close scalping positions early!");
        }
        
        if(!ScalpingOverridesMain && EnableTimeBasedExit)
        {
            PrintFormat("   ⚠️  WARNING: ScalpingOverridesMain=false with EnableTimeBasedExit=true");
            PrintFormat("           Consider setting ScalpingOverridesMain=true to avoid conflicts");
        }
        
        PrintFormat("   Base Pip Threshold: %.1f pips", BaseScalpingPips);
        PrintFormat("   Timeout: %d bars (FIXED: now uses bar-based calculation)", ScalpingTimeoutBars);
        PrintFormat("   Risk Percent: %.1f%%", ScalpingRiskPercent);
        PrintFormat("   Adaptive Threshold: %s", AdaptiveScalpingThreshold ? "ENABLED" : "DISABLED");
        PrintFormat("   Min Accuracy Required: %.1f%%", MinScalpingAccuracy);
        PrintFormat("   Override Main Strategy: %s", ScalpingOverridesMain ? "YES (recommended)" : "NO (potential conflicts)");
        
        // Show symbol-specific pip calculations
        double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
        PrintFormat("   Symbol Info: %s, Digits=%d, Point=%.8f, PipSize=%.8f", 
                   _Symbol, _Digits, _Point, pip_size);
        
        double threshold_points = BaseScalpingPips * pip_size;
        PrintFormat("   Threshold in Points: %.8f", threshold_points);
        
        // Test threshold calculation
        double test_threshold = GetAdaptiveScalpingThreshold();
        PrintFormat("   Current Adaptive Threshold: %.1f pips", test_threshold);
    }
}

double GetAdaptiveScalpingThreshold()
{
    if(!AdaptiveScalpingThreshold || !EnableScalpingStrategy) 
    {
        return BaseScalpingPips;
    }
    
    // Calculate average accuracy across all steps
    double total_accuracy = 0;
    int valid_steps = 0;
    
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        if(g_total_predictions[i] > 5) // Need minimum predictions for reliability
        {
            total_accuracy += g_accuracy_pct[i];
            valid_steps++;
        }
    }
    
    if(valid_steps == 0) 
    {
        return BaseScalpingPips; // Not enough data, use base
    }
    
    double avg_accuracy = total_accuracy / valid_steps;
    
    // Adaptive threshold: higher accuracy = more aggressive (lower threshold)
    // Lower accuracy = more conservative (higher threshold)
    double accuracy_factor = 1.0;
    
    if(avg_accuracy > 60.0)
        accuracy_factor = 0.7;  // 30% more aggressive
    else if(avg_accuracy > 50.0)
        accuracy_factor = 0.85; // 15% more aggressive
    else if(avg_accuracy < 40.0)
        accuracy_factor = 1.5;  // 50% more conservative
    else if(avg_accuracy < 45.0)
        accuracy_factor = 1.25; // 25% more conservative
    
    double adaptive_threshold = BaseScalpingPips * accuracy_factor;
    return MathMax(5.0, MathMin(25.0, adaptive_threshold)); // Keep within reasonable bounds
}

bool CheckScalpingOpportunity(const double &predicted_prices[], double current_price, int &best_step, double &target_price, ENUM_ORDER_TYPE &order_type)
{
    if(!EnableScalpingStrategy) return false;
    
    double threshold_pips = GetAdaptiveScalpingThreshold();
    double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
    double threshold_points = threshold_pips * pip_size;
    
    best_step = -1;
    double best_distance = 0;
    target_price = 0;
    
    // Check each prediction step for scalping opportunities
    for(int step = 0; step < PREDICTION_STEPS; step++)
    {
        double predicted_price = predicted_prices[step];
        double distance_points = MathAbs(predicted_price - current_price);
        
        // Check accuracy filter if we have enough data
        bool accuracy_ok = true;
        if(g_total_predictions[step] > 5)
        {
            if(g_accuracy_pct[step] < MinScalpingAccuracy)
            {
                accuracy_ok = false;
            }
        }
        
        if(!accuracy_ok) continue;
            
        if(distance_points > threshold_points)
        {
            if(distance_points > best_distance)
            {
                best_distance = distance_points;
                best_step = step;
                target_price = predicted_price;
                order_type = (predicted_price > current_price) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
            }
        }
    }
    
    if(best_step >= 0)
    {
        PrintFormat("🎯 SCALPING OPPORTUNITY FOUND: Step H+%d, Distance=%.1f pips, Target=%.5f", 
                   best_step + 1, best_distance / pip_size, target_price);
        return true;
    }

    return false;
}

bool ExecuteScalpingTrade(double target_price, int target_step, ENUM_ORDER_TYPE order_type)
{
    if(g_scalping_position.is_active) return false;
    
    MqlTick tick;
    if(!SymbolInfoTick(_Symbol, tick)) return false;
    
    double entry_price = (order_type == ORDER_TYPE_BUY) ? tick.ask : tick.bid;
    
    // Validate TP direction and distance
    bool tp_direction_valid = (order_type == ORDER_TYPE_BUY && target_price > entry_price) || 
                              (order_type == ORDER_TYPE_SELL && target_price < entry_price);

    if(!tp_direction_valid)
    {
        PrintFormat("❌ SCALPING TRADE FAILED: Invalid TP direction. Entry=%.5f, TP=%.5f", entry_price, target_price);
        return false;
    }
    
    double tp_distance = MathAbs(target_price - entry_price);
    double min_tp_distance = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
    
    if(tp_distance < min_tp_distance)
    {
        PrintFormat("❌ SCALPING TRADE FAILED: TP %.8f is too close to entry (min required: %.8f)", tp_distance, min_tp_distance);
        return false;
    }
    
    // Calculate lot size for scalping
    double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if(account_balance <= 0) return false;
    
    double scalping_risk_fraction;
    if(EnableKellyCriterion && ArraySize(g_kelly_trade_history) >= 5)
    {
        scalping_risk_fraction = GetConfidenceAdjustedKelly(g_last_confidence_score) * (ScalpingRiskPercent / RiskPercent);
    }
    else
    {
        scalping_risk_fraction = ScalpingRiskPercent / 100.0;
    }
    
    double scalping_risk_amount = account_balance * scalping_risk_fraction;
    double estimated_risk_points = MathAbs(target_price - entry_price) * 0.5; // Simple risk estimate
    if(estimated_risk_points <= 0) estimated_risk_points = 50 * _Point;

    double loss_for_one_lot = 0;
    if(!OrderCalcProfit(order_type, _Symbol, 1.0, entry_price, entry_price - estimated_risk_points, loss_for_one_lot)) return false;
    
    double loss_for_one_lot_abs = MathAbs(loss_for_one_lot);
    if(loss_for_one_lot_abs <= 0) return false;
    
    double lot_size = scalping_risk_amount / loss_for_one_lot_abs;
    
    // Apply volume constraints
    double min_volume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double max_volume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    double vol_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    lot_size = NormalizeDouble(MathMin(max_volume, MathMax(min_volume, MathFloor(lot_size / vol_step) * vol_step)), 2);
    
    if(lot_size <= 0) return false;
    
    // Execute the trade with TP set to predicted price
    double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
    string comment = StringFormat("ScalpTP H+%d %.1fp", target_step + 1, MathAbs(target_price - entry_price) / pip_size);
    
    bool success = (order_type == ORDER_TYPE_BUY) ? 
                   trade.Buy(lot_size, _Symbol, tick.ask, 0, target_price, comment) :
                   trade.Sell(lot_size, _Symbol, tick.bid, 0, target_price, comment);
    
    if(success)
    {
        g_scalping_position.is_active = true;
        g_scalping_position.entry_time = TimeCurrent();
        g_scalping_position.entry_price = entry_price;
        g_scalping_position.target_price = target_price;
        g_scalping_position.target_step = target_step;
        g_scalping_position.order_type = order_type;
        g_scalping_position.lot_size = lot_size;
        g_scalping_position.ticket = trade.ResultOrder();
        g_scalping_position.comment = comment;
        
        PrintFormat("✅ SCALPING TRADE EXECUTED (Ticket %d): H+%d to %.5f, Timeout %d bars", g_scalping_position.ticket, target_step + 1, target_price, ScalpingTimeoutBars);
        return true;
    }
    else
    {
        PrintFormat("❌ SCALPING TRADE FAILED: %s (Code: %d)", trade.ResultComment(), trade.ResultRetcode());
        return false;
    }
}

//+------------------------------------------------------------------+
//| TRADING HOURS MANAGEMENT FUNCTIONS
//+------------------------------------------------------------------+
bool IsValidTradingDay()
{
    if(!EnableTradingHours) return true;
    
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    
    switch(dt.day_of_week)
    {
        case 1: return TradingMonday;    // Monday
        case 2: return TradingTuesday;   // Tuesday  
        case 3: return TradingWednesday; // Wednesday
        case 4: return TradingThursday;  // Thursday
        case 5: return TradingFriday;    // Friday
        case 6: return TradingSaturday;  // Saturday
        case 0: return TradingSunday;    // Sunday
        default: return false;
    }
}

bool IsValidTradingHour()
{
    if(!EnableTradingHours) return true;
    
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    int current_hour = dt.hour;
    
    // Handle cases where trading hours span midnight
    if(TradingStartHour <= TradingEndHour)
    {
        // Normal case: 8:00 - 18:00
        return (current_hour >= TradingStartHour && current_hour < TradingEndHour);
    }
    else
    {
        // Spanning midnight: 20:00 - 06:00
        return (current_hour >= TradingStartHour || current_hour < TradingEndHour);
    }
}

bool IsNewsAvoidanceTime()
{
    if(!EnableTradingHours || !AvoidNewsHours) return false;
    
    // Parse news avoidance hours (format: "14:30-15:30")
    string parts[];
    if(StringSplit(NewsAvoidanceHours, '-', parts) != 2) return false;
    
    string start_time_parts[];
    string end_time_parts[];
    if(StringSplit(parts[0], ':', start_time_parts) != 2) return false;
    if(StringSplit(parts[1], ':', end_time_parts) != 2) return false;
    
    int start_hour = (int)StringToInteger(start_time_parts[0]);
    int start_min = (int)StringToInteger(start_time_parts[1]);
    int end_hour = (int)StringToInteger(end_time_parts[0]);
    int end_min = (int)StringToInteger(end_time_parts[1]);
    
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    
    int current_minutes = dt.hour * 60 + dt.min;
    int start_minutes = start_hour * 60 + start_min;
    int end_minutes = end_hour * 60 + end_min;
    
    if(start_minutes <= end_minutes)
    {
        // Normal case: 14:30 - 15:30
        return (current_minutes >= start_minutes && current_minutes <= end_minutes);
    }
    else
    {
        // Spanning midnight case
        return (current_minutes >= start_minutes || current_minutes <= end_minutes);
    }
}

bool IsValidTradingTime()
{
    if(!EnableTradingHours) return true;
    
    bool valid_day = IsValidTradingDay();
    bool valid_hour = IsValidTradingHour();
    bool not_news_time = !IsNewsAvoidanceTime();
    
    return (valid_day && valid_hour && not_news_time);
}

string GetTradingHoursStatus()
{
    if(!EnableTradingHours) return "24/7 ENABLED";
    
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    
    string status = "";
    
    // Check day
    if(!IsValidTradingDay())
    {
        string day_names[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
        status += "CLOSED (Day: " + day_names[dt.day_of_week] + ")";
        return status;
    }
    
    // Check hour
    if(!IsValidTradingHour())
    {
        status += StringFormat("CLOSED (Hour: %02d not in %02d-%02d)", 
                              dt.hour, TradingStartHour, TradingEndHour);
        return status;
    }
    
    // Check news avoidance
    if(IsNewsAvoidanceTime())
    {
        status += "CLOSED (News: " + NewsAvoidanceHours + ")";
        return status;
    }
    
    // All checks passed
    int minutes_until_close = 0;
    if(TradingStartHour <= TradingEndHour)
    {
        minutes_until_close = (TradingEndHour - dt.hour) * 60 - dt.min;
    }
    else
    {
        if(dt.hour >= TradingStartHour)
            minutes_until_close = (24 - dt.hour + TradingEndHour) * 60 - dt.min;
        else
            minutes_until_close = (TradingEndHour - dt.hour) * 60 - dt.min;
    }
    
    if(minutes_until_close > 60)
        status += StringFormat("OPEN (%dh %dm left)", minutes_until_close / 60, minutes_until_close % 60);
    else
        status += StringFormat("OPEN (%dm left)", minutes_until_close);
    
    return status;
}

void ManageTradingHoursPositions()
{
    if(!EnableTradingHours || !ClosePositionsOutsideHours) return;
    
    if(!IsValidTradingTime() && (PositionsTotal() > 0 || g_scalping_position.is_active))
    {
        PrintFormat("⏰ TRADING HOURS: Outside trading time, closing positions");
        
        // Close main positions
        if(PositionSelect(_Symbol))
        {
            PrintFormat("   Closing main position due to trading hours");
            trade.PositionClose(_Symbol);
        }
        
        // Close scalping position
        if(g_scalping_position.is_active)
        {
            PrintFormat("   Closing scalping position due to trading hours");
            if(trade.PositionClose(_Symbol))
            {
                g_scalping_position.is_active = false;
            }
        }
    }
}

void InitializeTradingHours()
{
    PrintFormat("⏰ TRADING HOURS INITIALIZATION:");
    PrintFormat("   Status: %s", EnableTradingHours ? "ENABLED" : "DISABLED");
    
    if(EnableTradingHours)
    {
        PrintFormat("   Trading Hours: %02d:00 - %02d:00", TradingStartHour, TradingEndHour);
        
        string active_days = "";
        if(TradingMonday) active_days += "Mon ";
        if(TradingTuesday) active_days += "Tue ";
        if(TradingWednesday) active_days += "Wed ";
        if(TradingThursday) active_days += "Thu ";
        if(TradingFriday) active_days += "Fri ";
        if(TradingSaturday) active_days += "Sat ";
        if(TradingSunday) active_days += "Sun ";
        
        PrintFormat("   Active Days: %s", active_days);
        PrintFormat("   News Avoidance: %s", AvoidNewsHours ? "ENABLED (" + NewsAvoidanceHours + ")" : "DISABLED");
        PrintFormat("   Close Outside Hours: %s", ClosePositionsOutsideHours ? "YES" : "NO");
        PrintFormat("   Current Status: %s", GetTradingHoursStatus());
        
        // Show timezone info
        MqlDateTime dt;
        TimeToStruct(TimeCurrent(), dt);
        PrintFormat("   Current Server Time: %02d:%02d (%s)", dt.hour, dt.min, 
                   IsValidTradingTime() ? "TRADING ALLOWED" : "TRADING BLOCKED");
    }
}

//+------------------------------------------------------------------+
//| ACCURACY TRACKING FUNCTIONS
//+------------------------------------------------------------------+
void AddStepPredictions(const double &predicted_prices[], datetime current_bar_time)
{
    double prediction_bar_close = iClose(_Symbol, PERIOD_H1, 1);
    if(prediction_bar_close <= 0) return;
    
    for(int step = 0; step < PREDICTION_STEPS; step++)
    {
        datetime window_end = current_bar_time + (g_AccuracyWindowBars * PeriodSeconds(PERIOD_H1));
        
        ENUM_PREDICTION_DIRECTION step_direction = DIR_NEUTRAL;
        if(predicted_prices[step] > prediction_bar_close + 0.0001) step_direction = DIR_BULLISH;
        else if(predicted_prices[step] < prediction_bar_close - 0.0001) step_direction = DIR_BEARISH;
        
        StepPrediction pred;
        pred.target_price = predicted_prices[step];
        pred.prediction_bar_time = current_bar_time;
        pred.window_end_time = window_end;
        pred.direction = step_direction;
        pred.step = step;
        pred.evaluated = false;
        pred.hit_within_window = false;
        
        int size = ArraySize(g_step_predictions);
        ArrayResize(g_step_predictions, size + 1);
        g_step_predictions[size] = pred;
    }
}

bool CheckPriceHitInWindow(const StepPrediction &prediction)
{
    datetime start_time = prediction.prediction_bar_time;
    datetime end_time = prediction.window_end_time;
    
    int prediction_bar_index = iBarShift(_Symbol, PERIOD_H1, prediction.prediction_bar_time);
    if(prediction_bar_index < 0) return false;
    double base_price = iClose(_Symbol, PERIOD_H1, prediction_bar_index + 1);
    
    for(int i = 0; i < g_AccuracyWindowBars; i++)
    {
        datetime check_time = start_time + (i * PeriodSeconds(PERIOD_H1));
        if(check_time > end_time) break;
        
        int bar_index = iBarShift(_Symbol, PERIOD_H1, check_time);
        if(bar_index < 0) continue;
        
        double bar_high = iHigh(_Symbol, PERIOD_H1, bar_index);
        double bar_low = iLow(_Symbol, PERIOD_H1, bar_index);
        double bar_close = iClose(_Symbol, PERIOD_H1, bar_index);
        
        if((prediction.direction == DIR_BULLISH && (prediction.target_price <= bar_high || bar_close > base_price)) ||
           (prediction.direction == DIR_BEARISH && (prediction.target_price >= bar_low || bar_close < base_price)) ||
           (prediction.direction == DIR_NEUTRAL && (MathAbs(bar_close - base_price) <= 0.0005)))
        {
            return true;
        }
    }
    return false;
}

void CheckStepPredictionAccuracy()
{
    if(ArraySize(g_step_predictions) == 0) return;
    
    datetime current_bar_time = iTime(_Symbol, PERIOD_H1, 0);
    int newly_evaluated = 0;
    
    for(int i = ArraySize(g_step_predictions) - 1; i >= 0; i--)
    {
        if(g_step_predictions[i].evaluated || current_bar_time < g_step_predictions[i].window_end_time) continue;

        bool was_hit = CheckPriceHitInWindow(g_step_predictions[i]);
        g_total_predictions[g_step_predictions[i].step]++;
        if(was_hit) g_total_hits[g_step_predictions[i].step]++;
        
        g_step_predictions[i].evaluated = true;
        newly_evaluated++;
    }
    
    if(newly_evaluated > 0 && ArraySize(g_step_predictions) > 100)
    {
        int removed_count = 0;
        for(int i = ArraySize(g_step_predictions) - 1; i >= 0; i--)
        {
            if(g_step_predictions[i].evaluated)
            {
                ArrayRemove(g_step_predictions, i, 1);
                removed_count++;
                if(removed_count > 50) break; // Clean in batches
            }
        }
    }
}
// Add this function near the top with other helper functions
string StringRepeat(string str, int count)
{
    string result = "";
    for(int i = 0; i < count; i++)
    {
        result += str;
    }
    return result;
}
//+------------------------------------------------------------------+
//| CORE HELPER FUNCTIONS
//+------------------------------------------------------------------+
void InitializeParameters()
{
   g_RiskPercent = RiskPercent; 
   g_MinimumRiskRewardRatio = MinimumRiskRewardRatio;
   g_RequiredConsistentSteps = RequiredConsistentSteps; 
   g_StaticStopLossPips = StaticStopLossPips;
   g_StaticTakeProfitPips = StaticTakeProfitPips; 
   g_ATR_Period = ATR_Period;
   g_ATR_SL_Multiplier = ATR_SL_Multiplier; 
   g_ATR_TP_Multiplier = ATR_TP_Multiplier;
   g_MinProfitPips = MinProfitPips; 
   g_EnableTimeBasedExit = EnableTimeBasedExit;
   g_MaxPositionHoldBars = MaxPositionHoldBars; 
   g_ExitBarMinute = InpExitBarMinute;
   g_EnableTrailingStop = EnableTrailingStop; 
   g_TrailingStartPips = TrailingStartPips;
   g_TrailingStopPips = TrailingStopPips; 
   g_EnableADXFilter = EnableADXFilter;
   g_ADX_Period = ADX_Period; 
   g_ADX_Threshold = ADX_Threshold;
   g_MinimumModelConfidence = MinimumModelConfidence;
   g_MinimumSignalConfidence = MinimumSignalConfidence;
   g_ClassificationSignalThreshold = ClassificationSignalThreshold;
   g_AccuracyLookbackOnInit = AccuracyLookbackOnInit;
   g_AccuracyWindowBars = AccuracyWindowBars;
   g_PredictionUpdateMinutes = PredictionUpdateMinutes;
   g_TradingLogicMode = TradingLogicMode;
   g_StopLossMode = StopLossMode;
   g_TakeProfitMode = TakeProfitMode;
}

bool LoadBacktestPredictions()
{
   ArrayFree(g_backtest_predictions); 
   g_backtest_prediction_idx = 0;
   
   if(!FileIsExist(BACKTEST_PREDICTIONS_FILE, FILE_COMMON)) 
   { 
      PrintFormat("FATAL: Backtest file not found in MQL5\\Common\\Files folder: %s", BACKTEST_PREDICTIONS_FILE); 
      return false; 
   }
     
   int file_handle = FileOpen(BACKTEST_PREDICTIONS_FILE, FILE_READ | FILE_TXT | FILE_ANSI | FILE_COMMON); 
   if(file_handle == INVALID_HANDLE) 
   { 
      PrintFormat("FATAL: Could not open backtest file. Code: %d", GetLastError()); 
      return false; 
   }
     
   if(!FileIsEnding(file_handle)) FileReadString(file_handle); // Skip header

   int count = 0;
   int expected_columns = 5 + PREDICTION_STEPS;

   while(!FileIsEnding(file_handle))
   {
      string line = FileReadString(file_handle);
      string fields[];
      if(StringSplit(line, ';', fields) != expected_columns) continue;
      
      datetime ts = StringToTime(fields[0]);
      if(ts == 0) continue;
      
      ArrayResize(g_backtest_predictions, count + 1);
      g_backtest_predictions[count].timestamp = ts;
      g_backtest_predictions[count].buy_prob = StringToDouble(fields[1]);
      g_backtest_predictions[count].sell_prob = StringToDouble(fields[2]);
      g_backtest_predictions[count].hold_prob = StringToDouble(fields[3]);
      g_backtest_predictions[count].confidence_score = StringToDouble(fields[4]);
      for(int i=0; i<PREDICTION_STEPS; i++) g_backtest_predictions[count].predicted_prices[i] = StringToDouble(fields[5+i]);
      count++;
   }
   FileClose(file_handle);
   return(count > 0);
}

bool FindPredictionForBar(datetime bar_time, BacktestPrediction &found_pred, bool reset_search_index=false)
{
   if(reset_search_index) g_backtest_prediction_idx = 0;
   
   long tolerance = PeriodSeconds(PERIOD_H1) / 2;

   for(int i = g_backtest_prediction_idx; i < ArraySize(g_backtest_predictions); i++)
   {
      if(MathAbs((long)g_backtest_predictions[i].timestamp - (long)bar_time) <= tolerance) 
      { 
         found_pred = g_backtest_predictions[i]; 
         g_backtest_prediction_idx = i;
         return true; 
      }
      if(g_backtest_predictions[i].timestamp > bar_time) return false;
   }
   return false;
}

void CalculateImprovedInitialAccuracy()
{
    if(g_AccuracyLookbackOnInit <= 0 || !EnablePricePredictionDisplay || ArraySize(g_backtest_predictions) == 0) return;
    
    MqlRates price_data[];
    int bars_needed = g_AccuracyLookbackOnInit + g_AccuracyWindowBars + 10;
    if(CopyRates(_Symbol, PERIOD_H1, 0, bars_needed, price_data) < bars_needed) return;
    ArraySetAsSeries(price_data, true);
    
    bool first_search = true;
    for(int i = g_AccuracyLookbackOnInit; i >= g_AccuracyWindowBars; i--)
    {
        if(i >= ArraySize(price_data)) continue;
        
        datetime prediction_time = price_data[i].time;
        BacktestPrediction pred_data;
        if(!FindPredictionForBar(prediction_time, pred_data, first_search)) continue;
        first_search = false;
        
        double base_price = price_data[i].close;
        for(int step = 0; step < PREDICTION_STEPS; step++)
        {
            double predicted_price = pred_data.predicted_prices[step];
            ENUM_PREDICTION_DIRECTION direction = (predicted_price > base_price + 0.0001) ? DIR_BULLISH : (predicted_price < base_price - 0.0001) ? DIR_BEARISH : DIR_NEUTRAL;
            bool was_hit = false;
            
            for(int window_bar = 0; window_bar < g_AccuracyWindowBars; window_bar++)
            {
                int check_index = i - window_bar - 1;
                if(check_index < 0 || check_index >= ArraySize(price_data)) continue;
                
                if((direction == DIR_BULLISH && (predicted_price <= price_data[check_index].high || price_data[check_index].close > base_price)) ||
                   (direction == DIR_BEARISH && (predicted_price >= price_data[check_index].low || price_data[check_index].close < base_price)) ||
                   (direction == DIR_NEUTRAL && MathAbs(price_data[check_index].close - base_price) <= 0.0005))
                { was_hit = true; break; }
            }
            g_total_predictions[step]++;
            if(was_hit) g_total_hits[step]++;
        }
    }
    g_backtest_prediction_idx = 0;
}

string GenerateRequestID() 
{ 
   MathSrand((int)(GetTickCount() & 0x7FFFFFFF)); 
   string id = (string)TimeLocal() + "_" + IntegerToString(MathRand()); 
   StringReplace(id, ":", "-"); StringReplace(id, " ", "_"); 
   return id; 
}

bool JsonGetValue(const string &json_string, const string &key, double &out_value)
{
   string search_key = "\"" + key + "\"";
   int key_pos = StringFind(json_string, search_key); if(key_pos < 0) return false;
   int colon_pos = StringFind(json_string, ":", key_pos); if(colon_pos < 0) return false;
   int next_comma_pos = StringFind(json_string, ",", colon_pos);
   int next_brace_pos = StringFind(json_string, "}", colon_pos);
   int end_pos = (next_comma_pos > 0 && (next_brace_pos < 0 || next_comma_pos < next_brace_pos)) ? next_comma_pos : next_brace_pos;
   if(end_pos < 0) end_pos = StringLen(json_string);
   string value_str = StringSubstr(json_string, colon_pos + 1, end_pos - (colon_pos + 1));
   StringTrimLeft(value_str); StringTrimRight(value_str);
   out_value = StringToDouble(value_str);
   return true;
}

// Replace the old SendToDaemon function
bool SendToDaemon(const double &features[], double current_price, double atr_val, DaemonResponse &response)
{
    return SendHttpRequest(features, current_price, atr_val, response);
}

//+------------------------------------------------------------------+
//| KELLY-ENHANCED LOT SIZE CALCULATION
//+------------------------------------------------------------------+
double CalculateLotSize(double stopLossPrice, double entryPrice, double prediction_confidence = 0.5)
{
    double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    if(accountBalance <= 0) return 0.0;
    
    double risk_fraction;
    
    // Integrated Kelly, Adaptive Learning, and Fixed Risk into one function.
    if(EnableKellyCriterion && ArraySize(g_kelly_trade_history) >= 5)
    {
        risk_fraction = GetConfidenceAdjustedKelly(prediction_confidence);
        PrintFormat("🎯 Sizing with Kelly: %.2f%% (Conf-adj)", risk_fraction * 100);
    }
    else
    {
        risk_fraction = g_RiskPercent / 100.0;
        PrintFormat("🎯 Sizing with Fixed Risk: %.2f%% (Kelly data insufficient)", g_RiskPercent);
    }
    
    // Apply adaptive risk multiplier on top of the base risk fraction
    if(EnableAdaptivePositionSizing && AdaptiveLearningMode != ADAPTIVE_DISABLED)
    {
        double risk_multiplier = GetAdaptiveRiskMultiplier();
        risk_fraction *= risk_multiplier;
        PrintFormat("   Adaptive Risk Multiplier: %.2fx -> Final Risk: %.2f%%", risk_multiplier, risk_fraction * 100);
    }
    
    double riskAmount = accountBalance * risk_fraction;
    
    double loss_for_one_lot = 0;
    ENUM_ORDER_TYPE orderType = (entryPrice > stopLossPrice) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
    
    if(!OrderCalcProfit(orderType, _Symbol, 1.0, entryPrice, stopLossPrice, loss_for_one_lot)) return 0.0;
    double loss_for_one_lot_abs = MathAbs(loss_for_one_lot);
    if(loss_for_one_lot_abs <= 0) return 0.0;
    
    double lotSize = riskAmount / loss_for_one_lot_abs;
    
    // Apply volume constraints
    double minVolume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double maxVolume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    double volStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    lotSize = NormalizeDouble(MathMin(maxVolume, MathMax(minVolume, MathFloor(lotSize / volStep) * volStep)), 2);
    
    PrintFormat("   Risk Amount: $%.2f -> Lot Size: %.2f", riskAmount, lotSize);
    return lotSize;
}

//+------------------------------------------------------------------+
//| FIXED TRAILING STOP MANAGEMENT
//+------------------------------------------------------------------+
void ManageTrailingStop()
{
   // FIXED: Rewritten for clarity and correctness.
   if(!g_EnableTrailingStop || !PositionSelect(_Symbol)) return;

   double entryPrice = PositionGetDouble(POSITION_PRICE_OPEN);
   double currentSL = PositionGetDouble(POSITION_SL);
   double currentTP = PositionGetDouble(POSITION_TP);
   long positionType = PositionGetInteger(POSITION_TYPE);

   MqlTick tick;
   if(!SymbolInfoTick(_Symbol, tick)) return;
   
   double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
   double trailingStartPoints = g_TrailingStartPips * pip_size;
   double trailingStopPoints = g_TrailingStopPips * pip_size;
   double stopsLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
   
   double newSL = 0;
   
   if(positionType == POSITION_TYPE_BUY)
   {
      if(tick.bid - entryPrice > trailingStartPoints) // In profit enough to trail
      {
         double potentialNewSL = tick.bid - trailingStopPoints;
         // Only modify if the new SL is higher than the current one
         if(potentialNewSL > currentSL)
         {
            // Ensure new SL is not too close to the current price
            if(tick.bid - potentialNewSL >= stopsLevel)
            {
               newSL = potentialNewSL;
            }
         }
      }
   }
   else if(positionType == POSITION_TYPE_SELL)
   {
      if(entryPrice - tick.ask > trailingStartPoints) // In profit enough to trail
      {
         double potentialNewSL = tick.ask + trailingStopPoints;
         // Only modify if the new SL is lower than the current one
         if(potentialNewSL < currentSL || currentSL == 0)
         {
            // Ensure new SL is not too close to the current price
            if(potentialNewSL - tick.ask >= stopsLevel)
            {
               newSL = potentialNewSL;
            }
         }
      }
   }
   
   // Execute modification if a valid new SL was calculated
   if(newSL != 0)
   {
      if(trade.PositionModify(_Symbol, NormalizeDouble(newSL, _Digits), currentTP))
      {
         PrintFormat("✅ TRAILING STOP update success. New SL: %.5f", newSL);
      }
      else
      {
         PrintFormat("❌ TRAILING STOP update failed: %s", trade.ResultComment());
      }
   }
}

//+------------------------------------------------------------------+
//| GUI PANEL FUNCTIONS (Enhanced with Kelly Display)
//+------------------------------------------------------------------+
void CreateDisplayPanel()
{
   if(!EnablePricePredictionDisplay) return;
   string bg_name = GUI_PREFIX + "background";
   ObjectCreate(0, bg_name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, bg_name, OBJPROP_XDISTANCE, 5);
   ObjectSetInteger(0, bg_name, OBJPROP_YDISTANCE, 20);
   ObjectSetInteger(0, bg_name, OBJPROP_XSIZE, 580); 
   ObjectSetInteger(0, bg_name, OBJPROP_YSIZE, 220 + (PREDICTION_STEPS * 80) + 30); // Increased height for D1 prediction
   ObjectSetInteger(0, bg_name, OBJPROP_BGCOLOR, C'20,20,40');
   ObjectSetInteger(0, bg_name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, bg_name, OBJPROP_BACK, true);
   
   string title_name = GUI_PREFIX + "title";
   ObjectCreate(0, title_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, title_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, title_name, OBJPROP_YDISTANCE, 20);
   ObjectSetString(0, title_name, OBJPROP_TEXT, "GGTH LSTM HTTP Enhanced (" + _Symbol + " H1) - 24-Bar Window");
   ObjectSetInteger(0, title_name, OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, title_name, OBJPROP_FONTSIZE, 9);
   
   string conn_label_name = GUI_PREFIX + "connection";
   ObjectCreate(0, conn_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, conn_label_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, conn_label_name, OBJPROP_YDISTANCE, 260);
   ObjectSetString(0, conn_label_name, OBJPROP_TEXT, "HTTP Daemon: Not Connected");
   ObjectSetInteger(0, conn_label_name, OBJPROP_COLOR, clrOrange);
   ObjectSetInteger(0, conn_label_name, OBJPROP_FONTSIZE, 8);
   
   string stats_label_name = GUI_PREFIX + "stats";
   ObjectCreate(0, stats_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, stats_label_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, stats_label_name, OBJPROP_YDISTANCE, 40);
   ObjectSetString(0, stats_label_name, OBJPROP_TEXT, "HTTP: 0/0");
   ObjectSetInteger(0, stats_label_name, OBJPROP_COLOR, clrSilver);
   ObjectSetInteger(0, stats_label_name, OBJPROP_FONTSIZE, 8);
   
   string adaptive_label_name = GUI_PREFIX + "adaptive";
   ObjectCreate(0, adaptive_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, adaptive_label_name, OBJPROP_XDISTANCE,1200);
   ObjectSetInteger(0, adaptive_label_name, OBJPROP_YDISTANCE, 60);
   ObjectSetString(0, adaptive_label_name, OBJPROP_TEXT, "🧠 Adaptive: Initializing...");
   ObjectSetInteger(0, adaptive_label_name, OBJPROP_COLOR, clrCyan);
   ObjectSetInteger(0, adaptive_label_name, OBJPROP_FONTSIZE, 8);
   
   string metrics_label_name = GUI_PREFIX + "metrics";
   ObjectCreate(0, metrics_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, metrics_label_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, metrics_label_name, OBJPROP_YDISTANCE, 80);
   ObjectSetString(0, metrics_label_name, OBJPROP_TEXT, "Conf: 0.40 | Risk: 1.0x");
   ObjectSetInteger(0, metrics_label_name, OBJPROP_COLOR, clrGold);
   ObjectSetInteger(0, metrics_label_name, OBJPROP_FONTSIZE, 8);
   
   string error_label_name = GUI_PREFIX + "error";
   ObjectCreate(0, error_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, error_label_name, OBJPROP_XDISTANCE, 20);
   ObjectSetInteger(0, error_label_name, OBJPROP_YDISTANCE, 100);
   ObjectSetString(0, error_label_name, OBJPROP_TEXT, "");
   ObjectSetInteger(0, error_label_name, OBJPROP_COLOR, clrTomato);
   ObjectSetInteger(0, error_label_name, OBJPROP_FONTSIZE, 7);
   
   string tz_label_name = GUI_PREFIX + "timezone";
   ObjectCreate(0, tz_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, tz_label_name, OBJPROP_XDISTANCE, 600);
   ObjectSetInteger(0, tz_label_name, OBJPROP_YDISTANCE, 60);
   ObjectSetString(0, tz_label_name, OBJPROP_TEXT, "Updates: Initializing...");
   ObjectSetInteger(0, tz_label_name, OBJPROP_COLOR, clrGold);
   ObjectSetInteger(0, tz_label_name, OBJPROP_FONTSIZE, 8);
   
   // Add tester learning status
   string tester_label_name = GUI_PREFIX + "tester";
   ObjectCreate(0, tester_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, tester_label_name, OBJPROP_XDISTANCE, 20);
   ObjectSetInteger(0, tester_label_name, OBJPROP_YDISTANCE, 40);
   ObjectSetString(0, tester_label_name, OBJPROP_TEXT, "🧪 Tester: Initializing...");
   ObjectSetInteger(0, tester_label_name, OBJPROP_COLOR, clrMagenta);
   ObjectSetInteger(0, tester_label_name, OBJPROP_FONTSIZE, 8);
   
   // Add scalping status
   string scalping_label_name = GUI_PREFIX + "scalping";
   ObjectCreate(0, scalping_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, scalping_label_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, scalping_label_name, OBJPROP_YDISTANCE, 160);
   ObjectSetString(0, scalping_label_name, OBJPROP_TEXT, "📈 Scalping: Initializing...");
   ObjectSetInteger(0, scalping_label_name, OBJPROP_COLOR, clrDeepSkyBlue);
   ObjectSetInteger(0, scalping_label_name, OBJPROP_FONTSIZE, 8);
   
   // Add trading hours status
   string hours_label_name = GUI_PREFIX + "hours";
   ObjectCreate(0, hours_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, hours_label_name, OBJPROP_XDISTANCE, 1200);
   ObjectSetInteger(0, hours_label_name, OBJPROP_YDISTANCE, 120);
   ObjectSetString(0, hours_label_name, OBJPROP_TEXT, "⏰ Hours: Initializing...");
   ObjectSetInteger(0, hours_label_name, OBJPROP_COLOR, clrLightSeaGreen);
   ObjectSetInteger(0, hours_label_name, OBJPROP_FONTSIZE, 8);
   
   // Add Kelly Criterion status
   string kelly_label_name = GUI_PREFIX + "kelly";
   ObjectCreate(0, kelly_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, kelly_label_name, OBJPROP_XDISTANCE,1200);
   ObjectSetInteger(0, kelly_label_name, OBJPROP_YDISTANCE, 230);
   ObjectSetString(0, kelly_label_name, OBJPROP_TEXT, "🎯 Kelly: Initializing...");
   ObjectSetInteger(0, kelly_label_name, OBJPROP_COLOR, clrGold);
   ObjectSetInteger(0, kelly_label_name, OBJPROP_FONTSIZE, 8);

   // NEW: Add Daily Prediction status
   string daily_pred_label_name = GUI_PREFIX + "daily_pred_label";
   ObjectCreate(0, daily_pred_label_name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, daily_pred_label_name, OBJPROP_XDISTANCE, 20); 
   ObjectSetInteger(0, daily_pred_label_name, OBJPROP_YDISTANCE, 160); 
   ObjectSetString(0, daily_pred_label_name, OBJPROP_TEXT, "📅 D1 Prediction: Initializing...");
   ObjectSetInteger(0, daily_pred_label_name, OBJPROP_FONTSIZE, 8);
   ObjectSetInteger(0, daily_pred_label_name, OBJPROP_COLOR, clrLightCyan);

   int y_pos = 200; // Adjusted from 180 to make space for D1 label
   for(int i = 0; i < PREDICTION_STEPS; i++)
   {
      string hour_label_name = GUI_PREFIX + "hour_" + (string)i;
      ObjectCreate(0, hour_label_name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, hour_label_name, OBJPROP_XDISTANCE, 20);
      ObjectSetInteger(0, hour_label_name, OBJPROP_YDISTANCE, y_pos);
      ObjectSetString(0, hour_label_name, OBJPROP_TEXT, StringFormat("H+%d:", i + 1));
      ObjectSetInteger(0, hour_label_name, OBJPROP_COLOR, clrSilver);
      ObjectSetInteger(0, hour_label_name, OBJPROP_FONTSIZE, 8);
      
      string price_label_name = GUI_PREFIX + "price_" + (string)i;
      ObjectCreate(0, price_label_name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, price_label_name, OBJPROP_XDISTANCE, 120);
      ObjectSetInteger(0, price_label_name, OBJPROP_YDISTANCE, y_pos);
      ObjectSetString(0, price_label_name, OBJPROP_TEXT, "Waiting for daemon...");
      ObjectSetInteger(0, price_label_name, OBJPROP_COLOR, clrWhite);
      ObjectSetInteger(0, price_label_name, OBJPROP_FONTSIZE, 8);
      
      string acc_label_name = GUI_PREFIX + "acc_" + (string)i;
      ObjectCreate(0, acc_label_name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, acc_label_name, OBJPROP_XDISTANCE, 280);
      ObjectSetInteger(0, acc_label_name, OBJPROP_YDISTANCE, y_pos);
      ObjectSetString(0, acc_label_name, OBJPROP_TEXT, "24-Bar Acc: Init...");
      ObjectSetInteger(0, acc_label_name, OBJPROP_COLOR, clrGray);
      ObjectSetInteger(0, acc_label_name, OBJPROP_FONTSIZE, 8);
      
      string weight_label_name = GUI_PREFIX + "weight_" + (string)i;
      ObjectCreate(0, weight_label_name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, weight_label_name, OBJPROP_XDISTANCE, 600);
      ObjectSetInteger(0, weight_label_name, OBJPROP_YDISTANCE, y_pos);
      ObjectSetString(0, weight_label_name, OBJPROP_TEXT, "W: 1.0");
      ObjectSetInteger(0, weight_label_name, OBJPROP_COLOR, clrLightBlue);
      ObjectSetInteger(0, weight_label_name, OBJPROP_FONTSIZE, 8);
      
      y_pos += 80;
   }
}

void UpdateDisplayPanel()
{
    // Always update accuracy calculations even if display is disabled
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        g_accuracy_pct[i] = (g_total_predictions[i] > 0) ? ((double)g_total_hits[i] / (double)g_total_predictions[i]) * 100.0 : 0.0;
    }
    
    if(!EnablePricePredictionDisplay) return;
    
    // Title & Confidence
    ObjectSetString(0, GUI_PREFIX + "title", OBJPROP_TEXT, StringFormat("GGTH LSTM HTTP Enhanced (%s H1) | Confidence: %.2f", _Symbol, g_last_confidence_score));
    
    // HTTP Connection Status
    string conn_text = StringFormat("HTTP Daemon: %s (%s:%d)", g_connection_status, DaemonHost, DaemonPort);
    if(g_last_http_request_time > 0) 
        conn_text += StringFormat(" (Last: %ds ago)", (int)(TimeCurrent() - g_last_http_request_time));
    
    ObjectSetString(0, GUI_PREFIX + "connection", OBJPROP_TEXT, conn_text);
    
    color conn_color = clrOrange;
    if(g_connection_status == "Connected") conn_color = clrLimeGreen;
    else if(g_connection_status == "Error") conn_color = clrTomato;
    
    ObjectSetInteger(0, GUI_PREFIX + "connection", OBJPROP_COLOR, conn_color);
    
    // HTTP Stats
    ObjectSetString(0, GUI_PREFIX + "stats", OBJPROP_TEXT, StringFormat("HTTP: %s", GetHttpConnectionStats()));
    
    // Error display
    string error_text = "";
    if(StringLen(g_last_http_error) > 0)
    {
        error_text = "HTTP Error: " + g_last_http_error;
        if(StringLen(error_text) > 70) error_text = StringSubstr(error_text, 0, 67) + "...";
    }
    ObjectSetString(0, GUI_PREFIX + "error", OBJPROP_TEXT, error_text);
    
    // Adaptive Learning
    string adaptive_text = "🧠 Adaptive: ";
    if(AdaptiveLearningMode == ADAPTIVE_DISABLED) adaptive_text += "DISABLED";
    else if(!g_adaptive_system_initialized) adaptive_text += "Initializing...";
    else if(ArraySize(g_trade_history) < MinTradesForAdaptation) adaptive_text += StringFormat("Learning (%d/%d)", ArraySize(g_trade_history), MinTradesForAdaptation);
    else adaptive_text += StringFormat("Active (%.1f%% success)", g_adaptive_metrics.success_rate_last_n_trades);
    ObjectSetString(0, GUI_PREFIX + "adaptive", OBJPROP_TEXT, adaptive_text);
    ObjectSetString(0, GUI_PREFIX + "metrics", OBJPROP_TEXT, StringFormat("Conf: %.3f | Risk: %.1fx | DD: %.1f%%", GetAdaptiveConfidenceThreshold(), GetAdaptiveRiskMultiplier(), g_current_drawdown));
    
    // Kelly Criterion status
    string kelly_text = "🎯 Kelly: ";
    if(!EnableKellyCriterion) kelly_text += "DISABLED";
    else if(ArraySize(g_kelly_trade_history) < 5) kelly_text += StringFormat("Learning (%d needed)", 5 - ArraySize(g_kelly_trade_history));
    else kelly_text += StringFormat("%.1f%% (WR:%.0f%% PF:%.1f)", g_current_kelly_fraction * 100, g_kelly_metrics.win_rate * 100, g_kelly_metrics.profit_factor);
    ObjectSetString(0, GUI_PREFIX + "kelly", OBJPROP_TEXT, kelly_text);
    
    // Daily Prediction
    if(EnableDailyPredictionDisplay)
    {
        string daily_text = "📅 D1 Pred: ";
        color daily_color = clrGray;
        if(g_last_daily_prediction_time > 0)
        {
            if(g_last_daily_prediction_direction == DIR_BULLISH) { daily_text += StringFormat("BULL (%.5f)", g_last_daily_prediction_price); daily_color = C'34,139,34'; }
            else if(g_last_daily_prediction_direction == DIR_BEARISH) { daily_text += StringFormat("BEAR (%.5f)", g_last_daily_prediction_price); daily_color = C'178,34,34'; }
            else { daily_text += "NEUTRAL"; daily_color = clrSilver; }
        } else { daily_text += "Waiting..."; }
        ObjectSetString(0, GUI_PREFIX + "daily_pred_label", OBJPROP_TEXT, daily_text);
        ObjectSetInteger(0, GUI_PREFIX + "daily_pred_label", OBJPROP_COLOR, daily_color);
    } else { ObjectSetString(0, GUI_PREFIX + "daily_pred_label", OBJPROP_TEXT, ""); }

    // Scalping Status
    string scalping_text = "📈 Scalping: ";
    if(!EnableScalpingStrategy) scalping_text += "DISABLED";
    else if(g_scalping_position.is_active) {
        int bars_elapsed = (int)((iTime(_Symbol, PERIOD_H1, 0) - iTime(_Symbol, PERIOD_H1, iBarShift(_Symbol, PERIOD_H1, g_scalping_position.entry_time))) / PeriodSeconds(PERIOD_H1));
        scalping_text += StringFormat("ACTIVE (H+%d, %d/%d bars)", g_scalping_position.target_step + 1, bars_elapsed, ScalpingTimeoutBars);
    } else { scalping_text += StringFormat("READY (%.1fp thld)", GetAdaptiveScalpingThreshold()); }
    ObjectSetString(0, GUI_PREFIX + "scalping", OBJPROP_TEXT, scalping_text);
    
    // Trading Hours Status
    string hours_text = "⏰ Hours: " + (EnableTradingHours ? GetTradingHoursStatus() : "24/7 ENABLED");
    ObjectSetString(0, GUI_PREFIX + "hours", OBJPROP_TEXT, hours_text);

    // Individual Step Predictions
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        ObjectSetString(0, GUI_PREFIX + "price_" + (string)i, OBJPROP_TEXT, (g_last_predictions[i] > 0) ? DoubleToString(g_last_predictions[i], _Digits) : "Waiting...");
        ObjectSetString(0, GUI_PREFIX + "acc_" + (string)i, OBJPROP_TEXT, (g_total_predictions[i] > 0) ? StringFormat("%.1f%% (%d/%d)", g_accuracy_pct[i], g_total_hits[i], g_total_predictions[i]) : "Acc: 0 preds");
        ObjectSetInteger(0, GUI_PREFIX + "acc_" + (string)i, OBJPROP_COLOR, (g_accuracy_pct[i] >= 60.0) ? clrLimeGreen : (g_accuracy_pct[i] >= 45.0) ? clrYellow : clrTomato);
        ObjectSetString(0, GUI_PREFIX + "weight_" + (string)i, OBJPROP_TEXT, StringFormat("W: %.2f", GetStepWeight(i)));
    }
    
    ChartRedraw();
}

void DeleteDisplayPanel() { ObjectsDeleteAll(0, GUI_PREFIX); ChartRedraw(); }

//+------------------------------------------------------------------+
//| MQL5 Main Event Handlers
//+------------------------------------------------------------------+
int OnInit()
{
    PrintFormat("=== GGTH EA v3.00 - HTTP Communication Version ===");
    
    // Build daemon URL
    g_daemon_base_url = BuildDaemonUrl();
    PrintFormat("🌐 Daemon URL: %s", g_daemon_base_url);
    
    // Initialize all systems
    InitializeParameters();
    InitializeAdaptiveLearning();
    InitializeKellySystem();
    
    // Load backtest data if needed
    if(MQLInfoInteger(MQL_TESTER) || g_AccuracyLookbackOnInit > 0)
    {
        if(!LoadBacktestPredictions() && MQLInfoInteger(MQL_TESTER))
            return(INIT_FAILED);
    }
    
    // Initialize indicators
    string symbols[] = {Symbol_EURJPY, Symbol_USDJPY, Symbol_GBPUSD, Symbol_EURGBP, Symbol_USDCAD, Symbol_USDCHF};
    for(int i = 0; i < ArraySize(symbols); i++) SymbolSelect(symbols[i], true);
    
    atr_handle = iATR(_Symbol, PERIOD_H1, g_ATR_Period);
    macd_handle = iMACD(_Symbol, PERIOD_H1, 12, 26, 9, PRICE_CLOSE);
    rsi_handle = iRSI(_Symbol, PERIOD_H1, 14, PRICE_CLOSE);
    stoch_handle = iStochastic(_Symbol, PERIOD_H1, 14, 3, 3, MODE_SMA, STO_LOWHIGH);
    cci_handle = iCCI(_Symbol, PERIOD_H1, 20, PRICE_TYPICAL);
    adx_handle = iADX(_Symbol, PERIOD_H1, g_ADX_Period);
    bb_handle = iBands(_Symbol, PERIOD_H1, 20, 0, 2, PRICE_CLOSE);
    
    if(atr_handle == INVALID_HANDLE || macd_handle == INVALID_HANDLE || 
       rsi_handle == INVALID_HANDLE || stoch_handle == INVALID_HANDLE || 
       cci_handle == INVALID_HANDLE || adx_handle == INVALID_HANDLE || 
       bb_handle == INVALID_HANDLE)
    {
        PrintFormat("❌ Failed to initialize indicators");
        return(INIT_FAILED);
    }
    
    // Initialize arrays
    ArrayInitialize(g_last_predictions, 0.0);
    ArrayInitialize(g_accuracy_pct, 0.0);
    ArrayInitialize(g_total_hits, 0);
    ArrayInitialize(g_total_predictions, 0);
    ArrayFree(g_step_predictions);
    
    // Create display panel
    CreateDisplayPanel();
    
    // Calculate initial accuracy if in tester
    if(MQLInfoInteger(MQL_TESTER))
        CalculateImprovedInitialAccuracy();
    
    // Test daemon communication if not in tester and enabled
    if(!MQLInfoInteger(MQL_TESTER) && TestDaemonOnStart)
    {
        PrintFormat("\n" + StringRepeat("=", 50));
        TestDaemonCommunication();
        PrintFormat(StringRepeat("=", 50) + "\n");
    }
    
    // Show URL allowlist reminder
    if(!MQLInfoInteger(MQL_TESTER))
    {
        PrintFormat("⚠️  IMPORTANT: Ensure the following URL is in your allowed WebRequest list:");
        PrintFormat("   Tools → Options → Expert Advisors → Allow WebRequest for URL:");
        PrintFormat("   %s", BuildDaemonUrl());
        PrintFormat("   %s", BuildDaemonUrl("health"));
        PrintFormat("   %s", BuildDaemonUrl("stats"));
    }
    
    UpdateDisplayPanel();
    return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
    if(g_adaptive_system_initialized)
    {
        SaveAdaptiveLearningData();
        SaveKellyTradeHistory();
        if(g_is_tester_mode)
        {
            RecordTesterResult();
            SaveTesterResults();
        }
    }
    
    IndicatorRelease(atr_handle);
    IndicatorRelease(macd_handle);
    IndicatorRelease(rsi_handle);
    IndicatorRelease(stoch_handle);
    IndicatorRelease(cci_handle);
    IndicatorRelease(adx_handle);
    IndicatorRelease(bb_handle);
    
    DeleteDisplayPanel();
    Comment("");
    
    PrintFormat("📊 HTTP Communication Statistics:");
    PrintFormat("   Total Requests: %d", g_http_requests_sent);
    PrintFormat("   Successful: %d", g_http_successful_responses);
    PrintFormat("   Failed: %d", g_http_failed_responses);
    if(g_http_requests_sent > 0)
        PrintFormat("   Success Rate: %.1f%%", (double)g_http_successful_responses / g_http_requests_sent * 100.0);
}

//+------------------------------------------------------------------+
//| MAIN TICK FUNCTION
//+------------------------------------------------------------------+
void OnTick()
{
    static datetime last_bar_time = 0;
    datetime current_bar_time = iTime(_Symbol, PERIOD_H1, 0);
    
    // --- POSITION MANAGEMENT FIRST ---
    ManageScalpingPosition();
    ManageTradingHoursPositions();
    
    if(PositionsTotal() > 0 && PositionSelect(_Symbol) && !IsScalpingPosition())
    {
        ManageTrailingStop();
        if(g_EnableTimeBasedExit)
        {
            datetime deadline = (datetime)PositionGetInteger(POSITION_TIME) + (g_MaxPositionHoldBars * PeriodSeconds(PERIOD_H1));
            if(TimeCurrent() >= deadline && (int)(TimeCurrent() % 3600 / 60) >= g_ExitBarMinute)
            {
                trade.PositionClose(_Symbol);
            }
        }
        return;
    }
    
    // --- NEW TRADE LOGIC ---
    bool is_new_bar = (current_bar_time != last_bar_time);
    bool is_time_update = (g_PredictionUpdateMinutes > 0 && (TimeCurrent() - g_last_prediction_time) / 60 >= g_PredictionUpdateMinutes);
    
    if(!is_new_bar && !is_time_update) return;
    if(PositionsTotal() > 0) return;
    
    last_bar_time = current_bar_time;
    CheckStepPredictionAccuracy();
    
    if(g_TradingLogicMode == MODE_TRADING_DISABLED || !IsValidTradingTime()) 
    {
        UpdateDisplayPanel();
        return;
    }
    
    DaemonResponse response;
    bool got_prediction = false;
    
    if(MQLInfoInteger(MQL_TESTER))
    {
        // Use backtest predictions in tester mode
        BacktestPrediction current_pred;
        if(FindPredictionForBar(iTime(_Symbol, PERIOD_H1, 1), current_pred))
        {
            ArrayCopy(response.prices, current_pred.predicted_prices, 0, 0, PREDICTION_STEPS);
            response.confidence_score = current_pred.confidence_score;
            response.buy_prob = current_pred.buy_prob;
            response.sell_prob = current_pred.sell_prob;
            got_prediction = true;
        }
    }
    else // Live mode - use HTTP communication
    {
        // Generate features array
        double features[FEATURE_COUNT * SEQ_LEN];
        int data_needed = SEQ_LEN + 30;
        MqlRates rates[];
        if(CopyRates(_Symbol, PERIOD_H1, 1, data_needed, rates) < data_needed) return;
        
        double macd[], rsi[], stoch_k[], cci[], upper_bb[], lower_bb[], atr[];
        double ej_c[], uj_c[], gu_c[], eg_c[], uc_c[], uchf_c[];
        
        if(CopyBuffer(macd_handle, 0, 1, data_needed, macd) < data_needed ||
           CopyBuffer(rsi_handle, 0, 1, data_needed, rsi) < data_needed ||
           CopyBuffer(stoch_handle, 0, 1, data_needed, stoch_k) < data_needed ||
           CopyBuffer(cci_handle, 0, 1, data_needed, cci) < data_needed ||
           CopyBuffer(bb_handle, 1, 1, data_needed, upper_bb) < data_needed ||
           CopyBuffer(bb_handle, 2, 1, data_needed, lower_bb) < data_needed ||
           CopyBuffer(atr_handle, 0, 1, data_needed, atr) < data_needed) return;
        
        if(CopyClose(Symbol_EURJPY, PERIOD_H1, 1, data_needed, ej_c) < data_needed ||
           CopyClose(Symbol_USDJPY, PERIOD_H1, 1, data_needed, uj_c) < data_needed ||
           CopyClose(Symbol_GBPUSD, PERIOD_H1, 1, data_needed, gu_c) < data_needed ||
           CopyClose(Symbol_EURGBP, PERIOD_H1, 1, data_needed, eg_c) < data_needed ||
           CopyClose(Symbol_USDCAD, PERIOD_H1, 1, data_needed, uc_c) < data_needed ||
           CopyClose(Symbol_USDCHF, PERIOD_H1, 1, data_needed, uchf_c) < data_needed) return;
        
        int f_idx = 0;
        for(int i = SEQ_LEN - 1; i >= 0; i--)
        {
            features[f_idx++] = (rates[i].close / rates[i + 1].close) - 1.0;
            features[f_idx++] = (double)rates[i].tick_volume;
            features[f_idx++] = atr[i];
            features[f_idx++] = macd[i];
            features[f_idx++] = rsi[i];
            features[f_idx++] = stoch_k[i];
            features[f_idx++] = cci[i];
            
            MqlDateTime dt;
            TimeToStruct(rates[i].time, dt);
            features[f_idx++] = (double)dt.hour;
            features[f_idx++] = (double)dt.day_of_week;
            
            features[f_idx++] = ((uj_c[i] / uj_c[i + 1] - 1.0) + (uc_c[i] / uc_c[i + 1] - 1.0) + (uchf_c[i] / uchf_c[i + 1] - 1.0)) - 
                               ((rates[i].close / rates[i + 1].close) - 1.0 + (gu_c[i] / gu_c[i + 1] - 1.0));
            features[f_idx++] = ((rates[i].close / rates[i + 1].close) - 1.0) + (ej_c[i] / ej_c[i + 1] - 1.0) + (eg_c[i] / eg_c[i + 1] - 1.0);
            features[f_idx++] = -((ej_c[i] / ej_c[i + 1] - 1.0) + (uj_c[i] / uj_c[i + 1] - 1.0));
            features[f_idx++] = (upper_bb[i] - lower_bb[i]) / (rates[i].close + 1e-10);
            features[f_idx++] = (double)rates[i].tick_volume - (double)rates[i + 5].tick_volume;
            
            double body = MathAbs(rates[i].close - rates[i].open);
            double range = rates[i].high - rates[i].low;
            double bar_type = 0;
            if(range > 0 && (body / range) < 0.1) bar_type = 1.0;
            if(rates[i].close > rates[i].open && rates[i].open < rates[i + 1].open && rates[i].close > rates[i + 1].close) bar_type = 2.0;
            if(rates[i].close < rates[i].open && rates[i].open > rates[i + 1].open && rates[i].close < rates[i + 1].close) bar_type = -2.0;
            bar_type += (rates[i].open - rates[i + 1].close) / (atr[i] + 1e-10);
            features[f_idx++] = bar_type;
        }
        
        MqlTick tick;
        if(!SymbolInfoTick(_Symbol, tick)) return;
        
        // This now uses HTTP instead of files
        if(SendToDaemon(features, tick.ask, atr[0], response))
        {
            got_prediction = true;
        }
    }
    
    if(!got_prediction)
    {
        UpdateDisplayPanel();
        return;
    }

    // Store latest prediction data globally
    ArrayCopy(g_last_predictions, response.prices, 0, 0, PREDICTION_STEPS);
    g_last_confidence_score = response.confidence_score;
    g_last_prediction_time = TimeCurrent();
    AddStepPredictions(response.prices, current_bar_time);
    
    // Simulate D1 prediction for the GUI panel
    if(EnableDailyPredictionDisplay)
    {
        int atr_d1_handle = iATR(_Symbol, PERIOD_D1, 14);
        double atr_d1_val[];
        if(CopyBuffer(atr_d1_handle, 0, 0, 1, atr_d1_val) > 0)
        {
            MqlTick tick;
            SymbolInfoTick(_Symbol, tick);
            int bullish = 0, bearish = 0;
            for(int i = 0; i < PREDICTION_STEPS; i++)
            {
                if(response.prices[i] > tick.ask) bullish++;
                if(response.prices[i] < tick.bid) bearish++;
            }
            if(bullish > bearish)
            {
                g_last_daily_prediction_price = response.prices[PREDICTION_STEPS - 1] + (atr_d1_val[0] * 0.5);
                g_last_daily_prediction_direction = DIR_BULLISH;
            }
            else if(bearish > bullish)
            {
                g_last_daily_prediction_price = response.prices[PREDICTION_STEPS - 1] - (atr_d1_val[0] * 0.5);
                g_last_daily_prediction_direction = DIR_BEARISH;
            }
            else
            {
                g_last_daily_prediction_price = iClose(_Symbol, PERIOD_D1, 1);
                g_last_daily_prediction_direction = DIR_NEUTRAL;
            }
            g_last_daily_prediction_time = TimeCurrent();
        }
        IndicatorRelease(atr_d1_handle);
    }

    // Check for scalping opportunity
    if(EnableScalpingStrategy && !g_scalping_position.is_active)
    {
        int best_step;
        double target_price;
        ENUM_ORDER_TYPE order_type;
        MqlTick tick;
        if(SymbolInfoTick(_Symbol, tick))
        {
            if(CheckScalpingOpportunity(response.prices, tick.ask, best_step, target_price, order_type))
            {
                if(ExecuteScalpingTrade(target_price, best_step, order_type) && ScalpingOverridesMain)
                {
                    UpdateDisplayPanel();
                    return; // Scalping trade executed, override complete.
                }
            }
        }
    }
    
    // --- MAIN STRATEGY TRADING LOGIC ---
    double adx[];
    if(g_EnableADXFilter && (CopyBuffer(adx_handle, 0, 1, 1, adx) < 1 || adx[0] < g_ADX_Threshold))
    {
        UpdateDisplayPanel();
        return;
    }
    
    if(g_last_confidence_score < GetAdaptiveConfidenceThreshold())
    {
        UpdateDisplayPanel();
        return;
    }

    MqlTick latest_tick;
    if(!SymbolInfoTick(_Symbol, latest_tick)) return;
    
    double atr_val[];
    if(CopyBuffer(atr_handle, 0, 1, 1, atr_val) < 1) return;
    
    double target_price = response.prices[TakeProfitTargetBar];
    double pip_size = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
    
    int bullish_steps = 0, bearish_steps = 0;
    for(int i = 0; i < PREDICTION_STEPS; i++)
    {
        if(response.prices[i] > latest_tick.ask) bullish_steps++;
        if(response.prices[i] < latest_tick.bid) bearish_steps++;
    }
    
    bool is_regr_buy = (double)bullish_steps / PREDICTION_STEPS >= g_MinimumSignalConfidence && bullish_steps >= g_RequiredConsistentSteps;
    bool is_regr_sell = (double)bearish_steps / PREDICTION_STEPS >= g_MinimumSignalConfidence && bearish_steps >= g_RequiredConsistentSteps;
    bool is_class_buy = response.buy_prob > g_ClassificationSignalThreshold;
    bool is_class_sell = response.sell_prob > g_ClassificationSignalThreshold;
    
    bool buy_signal = (g_TradingLogicMode == MODE_REGRESSION_ONLY) ? is_regr_buy : (is_regr_buy && is_class_buy);
    bool sell_signal = (g_TradingLogicMode == MODE_REGRESSION_ONLY) ? is_regr_sell : (is_regr_sell && is_class_sell);

    if(buy_signal)
    {
        double sl = (g_StopLossMode == SL_STATIC_PIPS) ? 
                   latest_tick.ask - (g_StaticStopLossPips * pip_size) : 
                   latest_tick.ask - (atr_val[0] * g_ATR_SL_Multiplier);
        
        if(latest_tick.ask - sl > 0 && (target_price - latest_tick.ask) / (latest_tick.ask - sl) >= g_MinimumRiskRewardRatio)
        {
            double tp = (g_TakeProfitMode == TP_REGRESSION_TARGET) ? target_price : 
                       (g_TakeProfitMode == TP_STATIC_PIPS) ? latest_tick.ask + (g_StaticTakeProfitPips * pip_size) : 
                       latest_tick.ask + (atr_val[0] * g_ATR_TP_Multiplier);
            
            double lots = CalculateLotSize(sl, latest_tick.ask, g_last_confidence_score);
            if(lots > 0)
            {
                if(trade.Buy(lots, _Symbol, latest_tick.ask, sl, tp, "GGTH LSTM HTTP Enhanced Buy"))
                {
                    RecordTrade(latest_tick.ask, tp, 0, g_last_confidence_score, lots, TakeProfitTargetBar);
                }
            }
        }
    }
    else if(sell_signal)
    {
        double sl = (g_StopLossMode == SL_STATIC_PIPS) ? 
                   latest_tick.bid + (g_StaticStopLossPips * pip_size) : 
                   latest_tick.bid + (atr_val[0] * g_ATR_SL_Multiplier);
        
        if(sl - latest_tick.bid > 0 && (latest_tick.bid - target_price) / (sl - latest_tick.bid) >= g_MinimumRiskRewardRatio)
        {
            double tp = (g_TakeProfitMode == TP_REGRESSION_TARGET) ? target_price : 
                       (g_TakeProfitMode == TP_STATIC_PIPS) ? latest_tick.bid - (g_StaticTakeProfitPips * pip_size) : 
                       latest_tick.bid - (atr_val[0] * g_ATR_TP_Multiplier);
            
            double lots = CalculateLotSize(sl, latest_tick.bid, g_last_confidence_score);
            if(lots > 0)
            {
                if(trade.Sell(lots, _Symbol, latest_tick.bid, sl, tp, "GGTH LSTM HTTP Enhanced Sell"))
                {
                    RecordTrade(latest_tick.bid, tp, 0, g_last_confidence_score, lots, TakeProfitTargetBar);
                }
            }
        }
    }
    
    // Update adaptive learning periodically
    if(AdaptiveLearningMode != ADAPTIVE_DISABLED && 
       ArraySize(g_trade_history) >= MinTradesForAdaptation &&
       (g_last_adaptation_time == 0 || TimeCurrent() - g_last_adaptation_time > 3600)) // Update hourly
    {
        PerformAdaptiveLearning();
    }
    
    UpdateDisplayPanel();
}