//+-----------------------------------------------...

//+------------------------------------------------------------------+
//| XAUUSD_AI_EA_v7.0.mq5 |
//| AI-Powered XAUUSD Trading Expert Advisor |
//| v7.40 – Production Ready |
//| Ensemble ML (LSTM + STCA + OneTrans) with Context |
//+------------------------------------------------------------------+
#property copyright "XAUUSD AI Team"
#property version "7.40"
#property description "Ensemble ML (LSTM, STCA, OneTrans) with Dynamic Weights"
#property description "Context Features, BOS/CHoCH, RSI Multi-TF, Bayesian Risk"
#property description "CPU-Optimized for Production Stability"
#property strict

//+------------------------------------------------------------------+
//| ПОДКЛЮЧЕНИЕ БИБЛИОТЕК |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <CFeatureEngine.mqh>
#include <EnsembleVoter.mqh>

//+------------------------------------------------------------------+
//| Встраивание ресурсов (ONNX модели и нормализация) |
//+------------------------------------------------------------------+
#resource "\Files\ONNX_models\lstm_xauusd.onnx" as uchar lstm_model_data[]
#resource "\Files\ONNX_models\stca_xauusd.onnx" as uchar stca_model_data[]
#resource "\Files\ONNX_models\onetrans_xauusd.onnx" as uchar onetrans_model_data[]
#resource "\Files\ONNX_models\mean.bin" as uchar mean_data[]
#resource "\Files\ONNX_models\scale.bin" as uchar scale_data[]

//+------------------------------------------------------------------+
//| Константы |
//+------------------------------------------------------------------+
#define FEATURE_COUNT 63
#define LSTM_LOOKBACK 60
#define TRANSFORMER_LOOKBACK 120
#define NUM_CLASSES 3
#define PANEL_X 10
#define PANEL_Y 30
#define PANEL_WIDTH 450
#define PANEL_HEIGHT 480
#define PANEL_FONT_SIZE 9
#define MAX_FEATURE_VALUE 1e4
#define NEWS_BLACKOUT_MINUTES 30

//+------------------------------------------------------------------+
//| Входные параметры |
//+------------------------------------------------------------------+
sinput group "=== Trading Settings ==="
sinput bool InpTradeEnabled = true;
sinput ENUM_TIMEFRAMES InpTimeframe = PERIOD_M1;
sinput string InpSymbolOverride = "";
sinput int InpMagicNumber = 20260324;
sinput double InpBaseRiskPercent = 0.5;
sinput double InpKellyFraction = 0.5;
sinput int InpStopLossATR = 2;
sinput int InpTakeProfitATR = 4;
sinput int InpMaxSpreadPoints = 40;
sinput int InpMaxSlippagePoints = 10;
sinput double InpMaxDailyLossPercent = 5.0;
sinput int InpMaxDailyTrades = 10;

sinput group "=== Filters & Protection ==="
sinput bool InpUseH1TrendFilter = true;
sinput bool InpUseNewsFilter = true;
sinput bool InpUseStopHuntProtect = true;
sinput int InpMaxPositions = 3;
sinput double InpStopHuntMultiplier = 1.5;
sinput int InpConsensusRequired = 2;
sinput bool InpAllowHedging = false;
sinput int InpMinBarsBetweenTrades = 5;
sinput bool InpUseBOSFilter = true;
sinput bool InpUseRSIMultiTF = true;
sinput double InpRSIOBLevel = 70.0;
sinput double InpRSIOSLevel = 30.0;
sinput int InpRSIConvergenceReq = 3;

sinput group "=== Advanced Analytics ==="
sinput bool InpUseWavelet = true;
sinput bool InpUseFractal = true;
sinput bool InpUseBayesian = true;
sinput bool InpUseMultiTF = true;
sinput bool InpUseRegimeAdapt = true;

sinput group "=== Dynamic Trailing Stop & Breakeven ==="
sinput bool InpUseTrailing = true;
sinput double InpTrailingStartRR = 1.0;
sinput int InpTrailingEmaPeriod = 20;
sinput double InpTrailingATRMult = 1.0;
sinput double InpBreakevenRR = 0.5;
sinput int InpBreakevenOffsetPoints = 10;

sinput group "=== Ensemble Voting ==="
sinput double InpConfidenceThreshold = 0.5;
sinput double InpBaseLSTMWeight = 1.0;
sinput double InpBaseSTCAWeight = 1.0;
sinput double InpBaseOneTransWeight = 1.0;
sinput double InpPriceThresholdPct = 0.05;

sinput group "=== CPU/GPU Performance ==="
sinput bool InpUseGPU = false;
sinput bool InpEnableCPUOptim = true;

sinput group "=== Debug ==="
sinput bool InpVerboseLogging = true;
sinput bool InpDisableTrading = false;
sinput bool InpShowPanel = true;
sinput bool InpLogTrades = true;

//+------------------------------------------------------------------+
//| Глобальные переменные |
//+------------------------------------------------------------------+
double g_mean[FEATURE_COUNT];
double g_scale[FEATURE_COUNT];
long g_lstm_handle = INVALID_HANDLE;
long g_stca_handle = INVALID_HANDLE;
long g_onetrans_handle = INVALID_HANDLE;

datetime g_last_bar_time = 0;
int g_bars_processed = 0;
double g_daily_pnl = 0;
int g_daily_trades = 0;
double g_h1_trend = 0;
datetime g_last_news_check = 0;
bool g_news_blackout = false;
double g_stop_hunt_prob = 0;
int g_open_positions = 0;
double g_current_atr = 0;
int g_last_signal = 0;
double g_last_signal_conf = 0;
datetime g_last_trade_time = 0;

double g_wavelet_signal = 0;
double g_fractal_dim = 0;
int g_vol_regime = 1;
double g_bayes_prob = 0.5;
double g_multi_tf_conv = 0;

int g_last_bos = 0;
int g_last_choch = 0;
int g_last_ob_count = 0;
int g_last_os_count = 0;
double g_weights[3] = {0.33, 0.33, 0.34};

int g_h1_ema50_handle = INVALID_HANDLE;
int g_h1_ema200_handle = INVALID_HANDLE;
int g_trail_ema_handle = INVALID_HANDLE;

CTrade g_trade;
CPositionInfo g_position;
CSymbolInfo g_symbol;
CAccountInfo g_account;
CFeatureEngine g_features;
CEnsembleVoter g_voter;

string g_panel_name = "AIPanel_";
bool g_panel_created = false;
int g_panel_lines = 24;

//+------------------------------------------------------------------+
//| ✅ ОБЪЯВЛЕНИЯ ФУНКЦИЙ (ПЕРЕД OnInit!) |
//+------------------------------------------------------------------+
void CreatePanel();
void UpdatePanel();
void DestroyPanel();
void UpdateDailyPnL();
double CalculateLot(double balance, double confidence, double stop_distance, int position_index);
bool OpenPosition(int signal, double confidence, double sl_distance, double tp_distance, int position_index, int model_used);
void ManageTrailingForPosition(ulong ticket);
void ManageAllPositions();
void CheckForEarlyExit();
void ClosePosition(ulong ticket);
bool GetONNXPredictions(double &lstm_out[], double &stca_out[], double &onetrans_out[]);

//+------------------------------------------------------------------+
//| Вспомогательные функции |
//+------------------------------------------------------------------+
union UDouble { double d; uchar c[8]; };

double CharArrayToDouble(const uchar &arr[], int offset)
{
UDouble u = {0};
for(int i=0; i<8; i++) u.c[i] = arr[offset+i];
return u.d;
}

double NormalizeLot(double lot)
{
double min_lot = g_symbol.LotsMin();
double max_lot = g_symbol.LotsMax();
double step = g_symbol.LotsStep();
if(step <= 0) step = 0.01;
lot = MathRound(lot / step) * step;
lot = MathMax(min_lot, MathMin(max_lot, lot));
return lot;
}

int CountOpenPositions()
{
int count = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket <= 0) continue;
if(!PositionSelectByTicket(ticket)) continue;
if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
count++;
}
return count;
}

bool CanOpenNewPosition(int signal)
{
int open_positions = CountOpenPositions();
if(open_positions >= InpMaxPositions) { if(InpVerboseLogging) Print("⏸️ Лимит позиций"); return false; }
if(!InpAllowHedging && open_positions > 0)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket <= 0) continue;
if(!PositionSelectByTicket(ticket)) continue;
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
ENUM_POSITION_TYPE pos_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
if((signal == 1 && pos_type == POSITION_TYPE_SELL) || (signal == -1 && pos_type == POSITION_TYPE_BUY))
{ if(InpVerboseLogging) Print("⏸️ Хеджирование запрещено"); return false; }
}
}
if(g_last_trade_time > 0 && InpMinBarsBetweenTrades > 0)
{
datetime cur_bar = iTime(_Symbol, InpTimeframe, 0);
int bars_since_last = (int)((cur_bar - g_last_trade_time) / PeriodSeconds(InpTimeframe));
if(bars_since_last < InpMinBarsBetweenTrades) { if(InpVerboseLogging) Print("⏸️ Слишком рано"); return false; }
}
return true;
}

double GetH1Trend()
{
if(g_h1_ema50_handle == INVALID_HANDLE) g_h1_ema50_handle = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_EMA, PRICE_CLOSE);
if(g_h1_ema200_handle == INVALID_HANDLE) g_h1_ema200_handle = iMA(_Symbol, PERIOD_H1, 200, 0, MODE_EMA, PRICE_CLOSE);
if(g_h1_ema50_handle == INVALID_HANDLE || g_h1_ema200_handle == INVALID_HANDLE) return 0.0;
double ema50_buf[1], ema200_buf[1], close_buf[1];
if(CopyBuffer(g_h1_ema50_handle, 0, 1, 1, ema50_buf) != 1) return 0;
if(CopyBuffer(g_h1_ema200_handle, 0, 1, 1, ema200_buf) != 1) return 0;
if(CopyClose(_Symbol, PERIOD_H1, 1, 1, close_buf) != 1) return 0;
double ema50 = ema50_buf[0], ema200 = ema200_buf[0], close = close_buf[0];
if(ema50 > ema200 && close > ema50) return 1.0;
if(ema50 < ema200 && close < ema50) return -1.0;
return 0.0;
}

bool IsNewsBlackout()
{
if(!InpUseNewsFilter) return false;
datetime now = TimeCurrent();
if(now - g_last_news_check < 60) return g_news_blackout;
g_last_news_check = now;
datetime from = now;
datetime to = now + NEWS_BLACKOUT_MINUTES * 60;
MqlCalendarValue values[];
if(!CalendarValueHistory(values, from, to, NULL, NULL))
{
g_news_blackout = false;
return false;
}
for(int i=0; i<ArraySize(values); i++)
{
MqlCalendarEvent event;
if(!CalendarEventById(values[i].event_id, event)) continue;
if(event.importance < 3) continue;
MqlCalendarCountry country;
if(!CalendarCountryById(event.country_id, country)) continue;
if(country.currency != "USD") continue;
g_news_blackout = true;
return true;
}
g_news_blackout = false;
return false;
}

bool LoadNormalizationParams()
{
if(ArraySize(mean_data) != FEATURE_COUNT * 8 || ArraySize(scale_data) != FEATURE_COUNT * 8)
{
Print("❌ Неверный размер ресурсов нормализации");
return false;
}
for(int i=0; i<FEATURE_COUNT; i++)
{
g_mean[i] = CharArrayToDouble(mean_data, i * 8);
g_scale[i] = CharArrayToDouble(scale_data, i * 8);
}
Print("✅ Параметры нормализации загружены");
return true;
}

//+------------------------------------------------------------------+
//| ✅ Инициализация ONNX моделей |
//+------------------------------------------------------------------+
bool InitONNXModels()
{
long onnx_flags = (InpUseGPU && !InpEnableCPUOptim) ? ONNX_DEFAULT : ONNX_USE_CPU_ONLY;
string mode_str = (onnx_flags == ONNX_USE_CPU_ONLY) ? "CPU" : "GPU";
Print("🧠 ONNX режим: ", mode_str);
Print("🔍 Система: CPU=", TerminalInfoInteger(TERMINAL_CPU_CORES), " ядер, RAM=", TerminalInfoInteger(TERMINAL_MEMORY_PHYSICAL), " MB");

// === LSTM ===
g_lstm_handle = OnnxCreateFromBuffer(lstm_model_data, onnx_flags);
if(g_lstm_handle == INVALID_HANDLE)
{
int err = GetLastError();
Print("❌ LSTM load error: код=", err);
return false;
}
Print("✅ LSTM загружена");

ulong input_shape_lstm[] = {1, LSTM_LOOKBACK, FEATURE_COUNT};
ulong output_shape[] = {1, NUM_CLASSES};

if(!OnnxSetInputShape(g_lstm_handle, 0, input_shape_lstm)) { Print("❌ LSTM SetInputShape error"); return false; }
if(!OnnxSetOutputShape(g_lstm_handle, 0, output_shape)) { Print("❌ LSTM SetOutputShape error"); return false; }

// === STCA ===
g_stca_handle = OnnxCreateFromBuffer(stca_model_data, onnx_flags);
if(g_stca_handle == INVALID_HANDLE)
{
Print("❌ STCA load error: ", GetLastError());
return false;
}
Print("✅ STCA загружена");

ulong input_shape_stca[] = {1, TRANSFORMER_LOOKBACK, FEATURE_COUNT};

if(!OnnxSetInputShape(g_stca_handle, 0, input_shape_stca)) { Print("❌ STCA SetInputShape error"); return false; }
if(!OnnxSetOutputShape(g_stca_handle, 0, output_shape)) { Print("❌ STCA SetOutputShape error"); return false; }

// === OneTrans (ДВА ВХОДА!) ===
g_onetrans_handle = OnnxCreateFromBuffer(onetrans_model_data, onnx_flags);
if(g_onetrans_handle == INVALID_HANDLE)
{
Print("❌ OneTrans load error: ", GetLastError());
return false;
}
Print("✅ OneTrans загружена");

ulong input_shape_onetrans_hist[] = {1, TRANSFORMER_LOOKBACK, FEATURE_COUNT};
ulong input_shape_onetrans_ctx[] = {1, FEATURE_COUNT};

if(!OnnxSetInputShape(g_onetrans_handle, 0, input_shape_onetrans_hist)) { Print("❌ OneTrans SetInputShape error: input 0"); return false; }
if(!OnnxSetInputShape(g_onetrans_handle, 1, input_shape_onetrans_ctx)) { Print("❌ OneTrans SetInputShape error: input 1"); return false; }
if(!OnnxSetOutputShape(g_onetrans_handle, 0, output_shape)) { Print("❌ OneTrans SetOutputShape error"); return false; }

Print("✅ ONNX модели настроены (LSTM + STCA + OneTrans)");
return true;
}

void DeInitONNXModels()
{
if(g_lstm_handle != INVALID_HANDLE) OnnxRelease(g_lstm_handle);
if(g_stca_handle != INVALID_HANDLE) OnnxRelease(g_stca_handle);
if(g_onetrans_handle != INVALID_HANDLE) OnnxRelease(g_onetrans_handle);
}

double CalculateLot(double balance, double confidence, double stop_distance, int position_index)
{
double base_risk = balance * InpBaseRiskPercent / 100.0;
double kelly = InpKellyFraction;
double risk_usd = base_risk * confidence * kelly;
if(InpUseRegimeAdapt)
{
if(g_vol_regime == 0) risk_usd *= 1.2;
else if(g_vol_regime == 2) risk_usd *= 0.7;
}
double tick_value = g_symbol.TickValue();
double tick_size = g_symbol.TickSize();
if(tick_size <= 0) tick_size = _Point;
double risk_ticks = stop_distance / tick_size;
if(risk_ticks <= 0) return 0;
double lot = risk_usd / (risk_ticks * tick_value);
return NormalizeLot(lot);
}

//+------------------------------------------------------------------+
//| ✅ Получение прогнозов ONNX – ИСПРАВЛЕНО |
//+------------------------------------------------------------------+
bool GetONNXPredictions(double &lstm_out[], double &stca_out[], double &onetrans_out[])
{
// ✅ Инициализация выходных массивов
if(ArraySize(lstm_out) < 3) ArrayResize(lstm_out, 3);
if(ArraySize(stca_out) < 3) ArrayResize(stca_out, 3);
if(ArraySize(onetrans_out) < 3) ArrayResize(onetrans_out, 3);
ArrayInitialize(lstm_out, 0.0);
ArrayInitialize(stca_out, 0.0);
ArrayInitialize(onetrans_out, 0.0);

// ✅ Входные массивы (double)
double lstm_input[];
double stca_input[];
double onetrans_input[];
double flat_input[];

// ✅ Контекстные признаки (2 параметра!)
double context_double[FEATURE_COUNT];
int ctx_size = 0;

if(!g_features.GetContextFeatures(context_double, ctx_size)) // ✅ 2 параметра
{
if(InpVerboseLogging) Print("❌ GetContextFeatures failed");
return false;
}

// ✅ Получаем данные из CFeatureEngine
if(!g_features.GetModelInputs(lstm_input, stca_input, onetrans_input, flat_input))
{
if(InpVerboseLogging) Print("❌ GetModelInputs failed");
return false;
}

// ✅ Проверка размеров
const int lstm_size = LSTM_LOOKBACK * FEATURE_COUNT;
const int trans_size = TRANSFORMER_LOOKBACK * FEATURE_COUNT;
const int ctx_size_expected = FEATURE_COUNT;

if(ArraySize(lstm_input) != lstm_size ||
ArraySize(stca_input) != trans_size ||
ArraySize(onetrans_input) != trans_size ||
ArraySize(flat_input) != ctx_size_expected)
{
Print("❌ Input size mismatch in GetONNXPredictions");
return false;
}

// ✅ Конвертация double → float для ONNX
float lstm_input_float[];
float stca_input_float[];
float onetrans_hist_float[];
float onetrans_ctx_float[];

ArrayResize(lstm_input_float, lstm_size);
ArrayResize(stca_input_float, trans_size);
ArrayResize(onetrans_hist_float, trans_size);
ArrayResize(onetrans_ctx_float, ctx_size_expected);

for(int i=0; i<lstm_size; i++) lstm_input_float[i] = (float)lstm_input[i];
for(int i=0; i<trans_size; i++)
{
stca_input_float[i] = (float)stca_input[i];
onetrans_hist_float[i] = (float)onetrans_input[i];
}
for(int i=0; i<ctx_size_expected; i++)
onetrans_ctx_float[i] = (float)context_double[i];

// ✅ Запуск LSTM
if(OnnxRun(g_lstm_handle, ONNX_DEFAULT, lstm_input_float, lstm_out) != 0)
{
Print("❌ LSTM OnnxRun error: ", GetLastError());
return false;
}

// ✅ Запуск STCA
if(OnnxRun(g_stca_handle, ONNX_DEFAULT, stca_input_float, stca_out) != 0)
{
Print("❌ STCA OnnxRun error: ", GetLastError());
return false;
}

// ✅ Запуск OneTrans (2 входа)
if(OnnxRun(g_onetrans_handle, ONNX_DEFAULT, onetrans_hist_float, onetrans_ctx_float, onetrans_out) != 0)
{
Print("❌ OneTrans OnnxRun error: ", GetLastError());
return false;
}

if(InpVerboseLogging)
{
Print("📊 Прогнозы моделей:");
Print(" LSTM: SELL=", DoubleToString(lstm_out[0], 4), " HOLD=", DoubleToString(lstm_out[1], 4), " BUY=", DoubleToString(lstm_out[2], 4));
Print(" STCA: SELL=", DoubleToString(stca_out[0], 4), " HOLD=", DoubleToString(stca_out[1], 4), " BUY=", DoubleToString(stca_out[2], 4));
Print(" OneTr: SELL=", DoubleToString(onetrans_out[0], 4), " HOLD=", DoubleToString(onetrans_out[1], 4), " BUY=", DoubleToString(onetrans_out[2], 4));
}
return true;
}

void UpdateDailyPnL()
{
datetime today = iTime(_Symbol, PERIOD_D1, 0);
static datetime last_reset = 0;
if(today != last_reset) { g_daily_pnl = 0; g_daily_trades = 0; last_reset = today; }
HistorySelect(today, TimeCurrent());
double total = 0; int trades = 0;
for(int i = HistoryDealsTotal() - 1; i >= 0; i--)
{
ulong ticket = HistoryDealGetTicket(i);
if(HistoryDealGetInteger(ticket, DEAL_MAGIC) == InpMagicNumber) { total += HistoryDealGetDouble(ticket, DEAL_PROFIT); trades++; }
}
g_daily_pnl = total; g_daily_trades = trades;
}

void CreatePanel()
{
if(!InpShowPanel) return;
DestroyPanel();
string name = g_panel_name + "bg";
if(ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, PANEL_X); ObjectSetInteger(0, name, OBJPROP_YDISTANCE, PANEL_Y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, PANEL_WIDTH); ObjectSetInteger(0, name, OBJPROP_YSIZE, PANEL_HEIGHT);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, clrBlack); ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, clrDarkGray);
ObjectSetInteger(0, name, OBJPROP_WIDTH, 1); ObjectSetInteger(0, name, OBJPROP_BACK, true); ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}
name = g_panel_name + "title";
if(ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, PANEL_X+5); ObjectSetInteger(0, name, OBJPROP_YDISTANCE, PANEL_Y+5);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 10); ObjectSetInteger(0, name, OBJPROP_COLOR, clrYellow);
ObjectSetString(0, name, OBJPROP_FONT, "Arial"); ObjectSetString(0, name, OBJPROP_TEXT, "🤖 XAUUSD AI EA v7.0");
}
for(int i=0; i<g_panel_lines; i++)
{
name = g_panel_name + "line" + IntegerToString(i);
if(ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, PANEL_X+5);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, PANEL_Y+25 + i*18);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, PANEL_FONT_SIZE);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
ObjectSetString(0, name, OBJPROP_FONT, "Consolas");
ObjectSetString(0, name, OBJPROP_TEXT, "Загрузка...");
}
}
g_panel_created = true;
}

void UpdatePanel()
{
if(!InpShowPanel || !g_panel_created) return;
double balance = g_account.Balance();
double equity = g_account.Equity();
double profit = equity - balance;
double drawdown = (balance > 0) ? ((balance - equity)/balance*100.0) : 0;
g_open_positions = CountOpenPositions();
double atr = g_features.GetATR();
g_current_atr = atr;

string signal_text = "-";
if(g_last_signal == 1) signal_text = "BUY";
else if(g_last_signal == -1) signal_text = "SELL";

string trend_text = "FLAT";
if(g_h1_trend == 1) trend_text = "BULL";
else if(g_h1_trend == -1) trend_text = "BEAR";

string news_text = "НЕТ";
if(g_news_blackout) news_text = "ДА";

string regime_text = "MED";
if(g_vol_regime == 0) regime_text = "LOW";
else if(g_vol_regime == 2) regime_text = "HIGH";

string lines[24];
lines[0] = StringFormat("Баланс: $lines[1] = StringFormat("Эквити:$%.2f", equity);
double profit_pct = (balance > 0) ? (profit/balance*100) : 0;
lines[2] = StringFormat("P/L: %+.2f (%.2f%%)", profit, profit_pct);
lines[3] = StringFormat("Просадка: %.2f%%", drawdown);
lines[4] = StringFormat("Спред: %d п.", g_symbol.Spread());
lines[5] = StringFormat("ATR(14): %.3f", atr);
lines[6] = StringFormat("Сделок сегодня: %d/%d", g_daily_trades, InpMaxDailyTrades);
lines[7] = StringFormat("Позиций: %d/%d", g_open_positions, InpMaxPositions);
lines[8] = StringFormat("Последний сигнал: %s (conf=%.2f)", signal_text, g_last_signal_conf);
lines[9] = StringFormat("Вер-ть стоп-ханта: %.2f", g_stop_hunt_prob);
lines[10] = StringFormat("Тренд H1: %s", trend_text);
lines[11] = StringFormat("News blackout: %s", news_text);
lines[12] = StringFormat("Обработано баров: %d", g_bars_processed);
lines[13] = StringFormat("Вейвлет: %.4f", g_wavelet_signal);
lines[14] = StringFormat("Фрактал: %.2f", g_fractal_dim);
lines[15] = StringFormat("Режим волат.: %s", regime_text);
lines[16] = StringFormat("Байес: %.2f", g_bayes_prob);
lines[17] = StringFormat("Конвергенция: %.2f", g_multi_tf_conv);
lines[18] = StringFormat("Импакт: %.2f", g_features.GetNewsImpact());
lines[19] = StringFormat("DXY/TNX: %.2f / %.2f", g_features.GetDXY(), g_features.GetTNX());
lines[20] = StringFormat("BOS/CHoCH: %d / %d", g_last_bos, g_last_choch);
lines[21] = StringFormat("RSI conv (OB/OS): %d / %d", g_last_ob_count, g_last_os_count);
lines[22] = StringFormat("Веса L/ST/OT: %.2f/%.2f/%.2f", g_weights[0], g_weights[1], g_weights[2]);
lines[23] = StringFormat("Кэш баров: %d", g_features.GetCachedBars());

for(int i=0; i<g_panel_lines; i++)
{
string nm = g_panel_name + "line" + IntegerToString(i);
color c = clrWhite;
if(i==2) { if(profit>=0) c = clrLimeGreen; else c = clrRed; }
if(i==7 && g_open_positions>0) c = clrLimeGreen;
if(i==7 && g_open_positions>=InpMaxPositions) c = clrOrange;
if(i==9 && g_stop_hunt_prob>0.5) c = clrOrange;
if(i==11 && g_news_blackout) c = clrRed;
if(i==15 && g_vol_regime==2) c = clrOrange;
if(i==15 && g_vol_regime==0) c = clrCyan;
ObjectSetString(0, nm, OBJPROP_TEXT, lines[i]);
ObjectSetInteger(0, nm, OBJPROP_COLOR, c);
}
ChartRedraw();
}

void DestroyPanel()
{
ObjectDelete(0, g_panel_name + "bg");
for(int i=0; i<g_panel_lines; i++) ObjectDelete(0, g_panel_name + "line" + IntegerToString(i));
ObjectDelete(0, g_panel_name + "title");
g_panel_created = false;
}

void ManageTrailingForPosition(ulong ticket)
{
if(!InpUseTrailing) return;
if(!PositionSelectByTicket(ticket)) return;
double atr = g_features.GetATR();
if(atr <= 0) return;
double current_sl = PositionGetDouble(POSITION_SL);
double current_tp = PositionGetDouble(POSITION_TP);
double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
double current_price = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? g_symbol.Bid() : g_symbol.Ask();
double new_sl = current_sl;
bool modified = false;
double profit_points = MathAbs(current_price - open_price) / _Point;
double risk_points = atr * InpStopLossATR / _Point;
double rr = (risk_points > 0) ? profit_points / risk_points : 0;
if(InpBreakevenRR > 0 && rr >= InpBreakevenRR && current_sl == 0)
{
double offset = InpBreakevenOffsetPoints * _Point;
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
new_sl = open_price - offset;
else
new_sl = open_price + offset;
modified = true;
}
if(InpUseTrailing && rr >= InpTrailingStartRR)
{
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
{
double trail = current_price - atr * InpTrailingATRMult;
if(trail > new_sl && trail < current_price) { new_sl = trail; modified = true; }
}
else
{
double trail = current_price + atr * InpTrailingATRMult;
if((new_sl == 0 || trail < new_sl) && trail > current_price) { new_sl = trail; modified = true; }
}
}
if(!modified) return;
new_sl = NormalizeDouble(new_sl, g_symbol.Digits());
if(new_sl != current_sl)
{
g_trade.SetExpertMagicNumber(InpMagicNumber);
g_trade.PositionModify(ticket, new_sl, current_tp);
}
}

void ManageAllPositions()
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket <= 0) continue;
if(!PositionSelectByTicket(ticket)) continue;
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
ManageTrailingForPosition(ticket);
}
}

void ClosePosition(ulong ticket)
{
MqlTradeRequest req = {}; MqlTradeResult res = {};
if(PositionSelectByTicket(ticket)) {
req.action = TRADE_ACTION_DEAL; req.position = ticket; req.symbol = _Symbol;
req.volume = PositionGetDouble(POSITION_VOLUME);
req.type = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
req.price = (req.type == ORDER_TYPE_SELL) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
req.type_filling = ORDER_FILLING_FOK;
if(!OrderSend(req, res)) Print("Close-Fehler: ", res.retcode);
}
}

void CheckForEarlyExit()
{
double rsi = 0;
int rsi_handle = iRSI(_Symbol, PERIOD_CURRENT, 14, PRICE_CLOSE);
if(rsi_handle != INVALID_HANDLE)
{
double rsi_buf[1];
if(CopyBuffer(rsi_handle, 0, 0, 1, rsi_buf) == 1) rsi = rsi_buf[0];
IndicatorRelease(rsi_handle);
}
for(int i = PositionsTotal() - 1; i >= 0; i--) {
ulong t = PositionGetTicket(i);
if(PositionSelectByTicket(t) && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber) {
long type = PositionGetInteger(POSITION_TYPE);
double profit = PositionGetDouble(POSITION_PROFIT);
if((type == POSITION_TYPE_BUY && rsi > 65.0 && profit > 0) ||
(type == POSITION_TYPE_SELL && rsi < 35.0 && profit > 0)) {
ClosePosition(t);
if(InpVerboseLogging) Print("Early exit by RSI, profit=", profit);
}
}
}
}

bool OpenPosition(int signal, double confidence, double sl_distance, double tp_distance, int position_index, int model_used)
{
if(!CanOpenNewPosition(signal)) return false;
double balance = g_account.Balance();
if(g_daily_pnl <= -balance * InpMaxDailyLossPercent / 100.0) { Print("❌ Дневной лимит убытка"); return false; }
if(g_daily_trades >= InpMaxDailyTrades) { Print("❌ Дневной лимит сделок"); return false; }
if(g_symbol.Spread() > InpMaxSpreadPoints) { if(InpVerboseLogging) Print("⏸️ Спред"); return false; }
if(InpUseStopHuntProtect)
{
g_stop_hunt_prob = g_features.GetStopHuntProbability();
if(g_stop_hunt_prob > 0.5) sl_distance *= InpStopHuntMultiplier;
}
double lot = CalculateLot(balance, confidence, sl_distance, position_index);
if(lot <= 0) return false;
double price, sl, tp; ENUM_ORDER_TYPE type;
g_symbol.RefreshRates();
if(signal == 1) { type = ORDER_TYPE_BUY; price = g_symbol.Ask(); sl = price - sl_distance; tp = price + tp_distance; }
else { type = ORDER_TYPE_SELL; price = g_symbol.Bid(); sl = price + sl_distance; tp = price - tp_distance; }
sl = NormalizeDouble(sl, g_symbol.Digits()); tp = NormalizeDouble(tp, g_symbol.Digits());
g_trade.SetExpertMagicNumber(InpMagicNumber);
g_trade.SetDeviationInPoints(InpMaxSlippagePoints);
if(g_trade.PositionOpen(_Symbol, type, lot, price, sl, tp, "AI EA"))
{
g_daily_trades++; g_last_trade_time = TimeCurrent();
PrintFormat("✅ %s #%d лот=%.2f цена=%.2f SL=%.2f TP=%.2f", (type==ORDER_TYPE_BUY?"BUY":"SELL"), PositionGetInteger(POSITION_TICKET), lot, price, sl, tp);
return true;
}
else { Print("❌ Ошибка открытия: ", g_trade.ResultRetcodeDescription()); return false; }
}

//+------------------------------------------------------------------+
//| ✅ OnInit |
//+------------------------------------------------------------------+
int OnInit()
{
Print("🚀 XAUUSD AI EA v7.0 инициализация...");
Print("🔍 Система: CPU=", TerminalInfoInteger(TERMINAL_CPU_CORES), " ядер, RAM=", TerminalInfoInteger(TERMINAL_MEMORY_PHYSICAL), " MB");

if(!g_symbol.Name(_Symbol)) { Print("❌ Ошибка символа"); return INIT_FAILED; }
if(!LoadNormalizationParams()) return INIT_FAILED;

g_features.SetMagicNumber(InpMagicNumber);
g_features.SetVerbose(InpVerboseLogging);
if(!g_features.Init(g_mean, g_scale)) return INIT_FAILED;
if(!g_features.InitIndicators()) return INIT_FAILED;
if(!InitONNXModels()) return INIT_FAILED;

EnsembleConfig cfg;
cfg.base_lstm_weight = InpBaseLSTMWeight;
cfg.base_transformer_weight = InpBaseSTCAWeight;
cfg.base_mlp_weight = InpBaseOneTransWeight;
cfg.confidence_threshold = InpConfidenceThreshold;
cfg.price_threshold_pct = InpPriceThresholdPct;
cfg.consensus_required = InpConsensusRequired;
g_voter.Init(cfg);

g_trade.SetExpertMagicNumber(InpMagicNumber);
CreatePanel();
UpdateDailyPnL();
EventSetTimer(1);

Print("✅ Инициализация завершена");
Print("📊 Настройки торговли: Enabled=", InpTradeEnabled, " Disable=", InpDisableTrading);
Print("📊 Фильтры: BOS=", InpUseBOSFilter, " H1=", InpUseH1TrendFilter, " RSI=", InpUseRSIMultiTF);
Print("📊 Порог уверенности: ", InpConfidenceThreshold);
return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| ✅ OnDeinit |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
DeInitONNXModels();
g_features.DeInit();
DestroyPanel();
EventKillTimer();
if(g_h1_ema50_handle != INVALID_HANDLE) IndicatorRelease(g_h1_ema50_handle);
if(g_h1_ema200_handle != INVALID_HANDLE) IndicatorRelease(g_h1_ema200_handle);
if(g_trail_ema_handle != INVALID_HANDLE) IndicatorRelease(g_trail_ema_handle);
Print("🛑 Советник выгружен, причина: ", reason);
}

//+------------------------------------------------------------------+
//| ✅ OnTimer |
//+------------------------------------------------------------------+
void OnTimer()
{
if(!InpTradeEnabled || InpDisableTrading)
{
if(InpVerboseLogging && g_bars_processed % 10 == 0)
Print("⏸️ Торговля отключена (Enabled=", InpTradeEnabled, " Disable=", InpDisableTrading, ")");
UpdatePanel();
return;
}

datetime cur_bar = iTime(_Symbol, InpTimeframe, 0);
if(cur_bar != g_last_bar_time)
{
g_last_bar_time = cur_bar;
UpdateDailyPnL();
g_bars_processed++;

text
  if(!g_features.IsReady())
  {
     if(InpVerboseLogging) Print("⏳ Ожидание готовности данных...");
     UpdatePanel();
     return;
  }

  if(InpUseWavelet) g_wavelet_signal = g_features.GetWaveletDenoised(0);
  if(InpUseFractal) g_fractal_dim = g_features.GetFractalDimension(50);
  if(InpUseRegimeAdapt) g_vol_regime = g_features.GetVolatilityRegime();
  if(InpUseBayesian) g_bayes_prob = g_features.GetBayesianTrendProb();
  if(InpUseMultiTF) g_multi_tf_conv = g_features.GetMultiTFConvergence();
  g_h1_trend = GetH1Trend();
  g_news_blackout = IsNewsBlackout();

  int bos = 0, choch = 0;
  if(InpUseBOSFilter) g_features.GetBOSCHoCHSignals(bos, choch);
  g_last_bos = bos; g_last_choch = choch;
  
  int ob = 0, os = 0;
  if(InpUseRSIMultiTF) g_features.GetRSIConvergence(InpRSIOBLevel, InpRSIOSLevel, ob, os);
  g_last_ob_count = ob; g_last_os_count = os;

  double weights[3];
  g_features.GetStrategyWeights(weights);
  g_voter.SetWeightsFromEngine(weights);
  g_weights[0] = weights[0]; g_weights[1] = weights[1]; g_weights[2] = weights[2];

  double lstm_out[3], stca_out[3], onetrans_out[3];
  if(!GetONNXPredictions(lstm_out, stca_out, onetrans_out))
  {
     if(InpVerboseLogging) Print("⚠️ Не удалось получить прогнозы моделей");
     UpdatePanel();
     return;
  }

  VotingResult res = g_voter.Vote(lstm_out[2], stca_out[2], onetrans_out[2], g_symbol.Bid(), g_current_atr);
  g_last_signal = res.signal;
  g_last_signal_conf = res.confidence;

  if(InpVerboseLogging && g_bars_processed % 5 == 0)
  {
     Print("📊 Сигнал: ", res.signal, " (conf=", DoubleToString(res.confidence, 2), ")");
     Print("   Фильтры: BOS=", bos, " RSI_OB=", ob, " RSI_OS=", os, " H1=", g_h1_trend);
  }

  if(res.signal != 0 && InpUseBOSFilter && bos != 0 && bos != res.signal)
  {
     if(InpVerboseLogging) Print("⏸️ BOS фильтр блокирует сигнал");
     res.signal = 0;
  }
  if(res.signal != 0 && InpUseRSIMultiTF)
  {
     if(res.signal == 1 && os >= InpRSIConvergenceReq) { if(InpVerboseLogging) Print("⏸️ RSI OS фильтр"); res.signal = 0; }
     if(res.signal == -1 && ob >= InpRSIConvergenceReq) { if(InpVerboseLogging) Print("⏸️ RSI OB фильтр"); res.signal = 0; }
  }
  if(res.signal != 0 && InpUseH1TrendFilter && g_h1_trend != 0 && g_h1_trend != res.signal)
  {
     if(InpVerboseLogging) Print("⏸️ H1 тренд фильтр");
     res.signal = 0;
  }

  if(res.signal != 0 && res.confidence >= InpConfidenceThreshold)
  {
     int open_positions = CountOpenPositions();
     double atr = g_features.GetATR();
     double sl_distance = atr * InpStopLossATR;
     double tp_distance = atr * InpTakeProfitATR;
     if(CanOpenNewPosition(res.signal))
     {
        Print("🎯 Открытие позиции: signal=", res.signal, " conf=", DoubleToString(res.confidence, 2));
        OpenPosition(res.signal, res.confidence, sl_distance, tp_distance, open_positions, 3);
     }
  }
  else if(InpVerboseLogging && res.signal != 0)
  {
     Print("⏸️ Сигнал отклонён: confidence=", DoubleToString(res.confidence, 2), " < threshold=", DoubleToString(InpConfidenceThreshold, 2));
  }

}

ManageAllPositions();
CheckForEarlyExit();
UpdatePanel();
}

//+------------------------------------------------------------------+
//| ✅ OnTick |
//+------------------------------------------------------------------+
void OnTick()
{
}

//+------------------------------------------------------------------+
//| ✅ OnTradeTransaction |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result)
{
if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
{
ulong ticket = trans.deal;
if(HistoryDealSelect(ticket) && HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
{
double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
g_features.UpdateBayesWithTradeOutcome(profit);
}
}
}
//+------------------------------------------------------------------+
//| CFeatureEngine.mqh |
//| Класс для расчёта и кэширования признаков |
//| XAUUSD_AI_EA_v7.36 - Production |
//| ✅ 4 параметра для GetModelInputs |
//+------------------------------------------------------------------+
#property copyright "XAUUSD AI Team"
#property version "7.36"
#property strict
#include <Arrays\ArrayDouble.mqh>
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Math\Stat\Math.mqh>

//+------------------------------------------------------------------+
//| Константы конфигурации |
//+------------------------------------------------------------------+
#define FEATURE_COUNT 63
#define HISTORY_BARS_MAX 200
#define LSTM_LOOKBACK 60
#define TRANSFORMER_LOOKBACK 120
#define MIN_BARS_REQUIRED 150
#define VWAP_LOOKBACK 20
#define CORR_LOOKBACK 50
#define MACRO_CACHE_SECONDS 60
#define NEWS_CACHE_SECONDS 3600
#define CORR_CACHE_SECONDS 900
#define MAX_FEATURE_VALUE 1e4
#define WAVELET_LEVEL 4
#define REGIME_HISTORY 50
#define MACRO_HISTORY_SIZE 100
#define BAYES_PRIOR_ALPHA 1.0
#define BAYES_PRIOR_BETA 1.0
#define CONTEXT_DIM 63
#define STRATEGY_WEIGHT_UPDATE_HOURS 1
#define STARTUP_BARS_TO_LOAD 250
#define ZIGZAG_INIT_DELAY 500

//+------------------------------------------------------------------+
//| Индексы признаков |
//+------------------------------------------------------------------+
enum FeatureIndex
{
F_OPEN=0, F_HIGH, F_LOW, F_CLOSE, F_VOLUME,
F_RSI=5, F_ATR, F_MACD_MAIN, F_MACD_SIGNAL, F_MACD_HIST,
F_EMA20, F_EMA50, F_SMA20, F_SMA50,
F_BB_UPPER, F_BB_MIDDLE, F_BB_LOWER, F_BB_WIDTH,
F_STOCH_K, F_STOCH_D, F_CCI, F_WILLR,
F_OBV, F_MFI, F_VWAP,
F_TENKAN, F_KIJUN, F_SENKOU_A, F_SENKOU_B,
F_PLUS_DI, F_MINUS_DI, F_ADX,
F_HURST_20=30, F_HURST_50, F_HURST_100,
F_FVG_SIZE=33, F_OB_STRENGTH,
F_EMA_CROSS_9_21=35, F_EMA_CROSS_12_26, F_EMA_CROSS_20_50,
F_CHAN_UPPER=38, F_CHAN_LOWER, F_CHAN_WIDTH,
F_MONTH=41, F_QUARTER, F_MONTH_SIN, F_MONTH_COS,
F_CORR_XAG=45, F_CORR_XPT, F_CORR_USDCNH,
F_DXY=48, F_TNX, F_NEWS_IMPACT,
F_RET_1=51, F_RET_5, F_RET_20,
F_VOLATILITY_20, F_SKEW_20, F_KURTOSIS_20,
F_PRICE_POS_BB,
F_VOL_RATIO, F_VOL_CHANGE, F_ACCUM_DIST,
F_ACCELERATION=61,
F_OBV_NORM=62
};

//+------------------------------------------------------------------+
//| Класс для кэширования корреляций |
//+------------------------------------------------------------------+
struct CorrCacheItem
{
string symbol;
int period;
datetime last_update;
double value;
CorrCacheItem() : symbol(""), period(0), last_update(0), value(0.0) {}
};

//+------------------------------------------------------------------+
//| Класс CFeatureEngine |
//+------------------------------------------------------------------+
class CFeatureEngine
{
private:
int m_feature_count;
datetime m_last_bar_time;
int m_cached_bars;
double m_mean[FEATURE_COUNT];
double m_scale[FEATURE_COUNT];
bool m_params_loaded;
bool m_history_loaded;
double m_cache[][FEATURE_COUNT];

struct IndicatorHandles
{
int rsi, atr, macd, bb, stoch;
int ema20, ema50, sma20, sma50, ema9, ema21, ema12, ema26;
int adx, cci, willr, obv, mfi;
IndicatorHandles()
{
rsi=atr=macd=bb=stoch=INVALID_HANDLE;
ema20=ema50=sma20=sma50=ema9=ema21=ema12=ema26=INVALID_HANDLE;
adx=cci=willr=obv=mfi=INVALID_HANDLE;
}
} m_h;

struct MacroCache
{
datetime last_update;
double dxy, tnx, news_impact;
double news_prev_impact;
datetime last_news_time;
ulong last_news_id;
MacroCache() : last_update(0), dxy(100.0), tnx(4.0), news_impact(0.0),
news_prev_impact(0.0), last_news_time(0), last_news_id(0) {}
} m_macro;

CorrCacheItem m_corr_xag;
CorrCacheItem m_corr_xpt;
CorrCacheItem m_corr_usdcnh;

double m_htf_cache[][1];
double m_h4_cache[][1];
int m_htf_handle;
int m_h4_handle;

struct MacroRecord
{
datetime time;
double dxy;
double tnx;
double news;
};
MacroRecord m_macro_history[MACRO_HISTORY_SIZE];
int m_macro_history_index;
int m_macro_history_count;
double m_bayes_alpha;
double m_bayes_beta;
double m_last_bayes_prob;
double m_vol_threshold_low;
double m_vol_threshold_high;

struct ContextCache
{
datetime last_update;
double positions_count;
double pnl;
double equity_ratio;
double margin_usage;
double open_volume;
double winning_rate_short;
double avg_trade_duration;
} m_context;
bool m_context_valid;

int m_zigzag_handle;
datetime m_last_zigzag_update;
datetime m_zigzag_created_time;
double m_strategy_weights[3];
datetime m_last_weight_update;

int m_model_total[3];
int m_model_correct[3];

int m_magic_number;
bool m_verbose;

double CalculateVWAP(int shift, int lookback);
double CalculateHurst(int shift, int period);
double CalculateFVG(int shift);
double CalculateOBStrength(int shift);
double CalculateCorrelation(string symbol, int period);
double CalculateNewsImpact();
bool IsImportantEvent(ulong event_id);
string GetEventCurrency(ulong event_id);
void UpdateHTFData();
void WaveletDecompose(const double &input_array[], int level, double &output[]);
double SoftThreshold(double x, double thr);
double EstimateNoiseLevel(const double &detail[]);
bool CopyIndicator(int handle, int buffer, int shift, int count, double &array[]);
void NormalizeFeature(double &value, int idx);
bool EnsureSymbolAvailable(string symbol);
double ClampValue(double val);
bool LoadHistoricalData(int bars_to_load);
bool IndicatorCheckValid(int handle);
bool SafeCopyBuffer(int handle, int buffer, int shift, int count, double &array[]);

public:
CFeatureEngine();
~CFeatureEngine();
bool Init(double &mean[], double &scale[]);
bool InitIndicators();
void DeInit();
void SetMagicNumber(int magic) { m_magic_number = magic; }
void SetVerbose(bool verbose) { m_verbose = verbose; }
bool Update();
bool CalculateFeaturesForBar(int shift, double &feat[]);
bool GetCurrentFeatures(double &feat[]);
// ✅ ИСПРАВЛЕНО: 4 параметра для LSTM, STCA, OneTrans, flat
bool GetModelInputs(double &lstm_input[], double &trans_input[], double &onetrans_input[], double &flat_input[]);
int GetFeatureCount() const { return FEATURE_COUNT; }
datetime GetLastUpdateTime() const { return m_last_bar_time; }
bool IsReady() const { return m_cached_bars >= MIN_BARS_REQUIRED && m_params_loaded && m_history_loaded; }
int GetCachedBars() const { return m_cached_bars; }
double GetATR() { double arr[1]; if(SafeCopyBuffer(m_h.atr,0,1,1,arr)) return arr[0]; return 0; }
double GetEMA20() { double arr[1]; if(SafeCopyBuffer(m_h.ema20,0,1,1,arr)) return arr[0]; return 0; }
double GetDXY();
double GetTNX();
double GetNewsImpact();
double GetWaveletDenoised(int shift);
double GetFractalDimension(int period);
int GetVolatilityRegime();
double GetBayesianTrendProb();
double GetMultiTFConvergence();
double GetMomentumCluster();
void UpdateRegimeThresholds();
void RecordMacroFactors();
void UpdateBayesWithTradeOutcome(double profit);
double GetPolygonalMA(int shift, int period, int poly);
double GetLiquidityDistance(int shift, double &strength);
double GetStopHuntProbability();
bool UpdateContextCache();
bool GetContextFeatures(double &context[], int &size);
int GetRSIConvergence(double ob_level, double os_level, int &count_ob, int &count_os);
bool GetBOSCHoCHSignals(int &bos_signal, int &choch_signal);
bool UpdateStrategyWeights();
void GetStrategyWeights(double &weights[]);
};

//+------------------------------------------------------------------+
//| Конструктор |
//+------------------------------------------------------------------+
CFeatureEngine::CFeatureEngine() :
m_feature_count(FEATURE_COUNT),
m_last_bar_time(0),
m_cached_bars(0),
m_params_loaded(false),
m_history_loaded(false),
m_htf_handle(INVALID_HANDLE),
m_h4_handle(INVALID_HANDLE),
m_macro_history_index(0),
m_macro_history_count(0),
m_bayes_alpha(BAYES_PRIOR_ALPHA),
m_bayes_beta(BAYES_PRIOR_BETA),
m_last_bayes_prob(0.5),
m_vol_threshold_low(0.0),
m_vol_threshold_high(0.0),
m_context_valid(false),
m_zigzag_handle(INVALID_HANDLE),
m_last_zigzag_update(0),
m_zigzag_created_time(0),
m_last_weight_update(0),
m_magic_number(0),
m_verbose(false)
{
ArrayInitialize(m_mean, 0.0);
ArrayInitialize(m_scale, 1.0);
ArrayResize(m_cache, 0);
ArrayResize(m_htf_cache, 0, 1);
ArrayResize(m_h4_cache, 0, 1);
m_strategy_weights[0] = 1.0/3.0;
m_strategy_weights[1] = 1.0/3.0;
m_strategy_weights[2] = 1.0/3.0;
ArrayInitialize(m_model_total, 0);
ArrayInitialize(m_model_correct, 0);
}

//+------------------------------------------------------------------+
//| Деструктор |
//+------------------------------------------------------------------+
CFeatureEngine::~CFeatureEngine()
{
DeInit();
if(m_htf_handle != INVALID_HANDLE) IndicatorRelease(m_htf_handle);
if(m_h4_handle != INVALID_HANDLE) IndicatorRelease(m_h4_handle);
if(m_zigzag_handle != INVALID_HANDLE) IndicatorRelease(m_zigzag_handle);
}

//+------------------------------------------------------------------+
//| SafeCopyBuffer – безопасное копирование буфера |
//+------------------------------------------------------------------+
bool CFeatureEngine::SafeCopyBuffer(int handle, int buffer, int shift, int count, double &array[])
{
if(handle == INVALID_HANDLE)
{
ArrayResize(array, count);
ArrayInitialize(array, 0.0);
return false;
}
ArrayResize(array, count);
ArrayInitialize(array, 0.0);
int copied = CopyBuffer(handle, buffer, shift, count, array);
if(copied != count)
{
ArrayInitialize(array, 0.0);
return false;
}
return true;
}

//+------------------------------------------------------------------+
//| Загрузка исторических данных при старте |
//+------------------------------------------------------------------+
bool CFeatureEngine::LoadHistoricalData(int bars_to_load)
{
if(m_history_loaded) return true;

Print("📥 Загрузка истории: ", bars_to_load, " баров...");

MqlRates rates[];
ArraySetAsSeries(rates, false);
int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, bars_to_load, rates);

if(copied < bars_to_load)
{
Print("⚠️ Загружено только ", copied, " из ", bars_to_load, " баров");
if(copied < MIN_BARS_REQUIRED)
{
Print("❌ Недостаточно данных для работы!");
return false;
}
}

int bars_to_use = MathMin(copied, HISTORY_BARS_MAX);
if(bars_to_use <= 0)
{
Print("❌ bars_to_use = 0, невозможно продолжить");
return false;
}

ArrayResize(m_cache, bars_to_use);

for(int i = 0; i < bars_to_use; i++)
{
double feat[FEATURE_COUNT];
if(CalculateFeaturesForBar(i, feat))
{
for(int j = 0; j < FEATURE_COUNT; j++)
m_cache[i][j] = feat[j];
}
else
{
for(int j = 0; j < FEATURE_COUNT; j++)
m_cache[i][j] = 0.0;
if(m_verbose) Print("⚠️ Ошибка расчёта признаков для бара ", i);
}
}

m_cached_bars = bars_to_use;
m_last_bar_time = rates[copied-1].time;
m_history_loaded = true;

Print("✅ История загружена: ", m_cached_bars, " баров, последний: ", TimeToString(m_last_bar_time));
UpdateRegimeThresholds();
return true;
}

//+------------------------------------------------------------------+
//| Инициализация параметров нормализации |
//+------------------------------------------------------------------+
bool CFeatureEngine::Init(double &mean[], double &scale[])
{
if(ArraySize(mean) != FEATURE_COUNT || ArraySize(scale) != FEATURE_COUNT)
{
Print("❌ FeatureEngine: размер параметров не совпадает");
return false;
}
ArrayCopy(m_mean, mean);
ArrayCopy(m_scale, scale);
for(int i=0; i<FEATURE_COUNT; i++)
if(m_scale[i] < 1e-10) m_scale[i] = 1.0;
m_params_loaded = true;
Print("✅ FeatureEngine: загружено ", FEATURE_COUNT, " параметров");
return true;
}

//+------------------------------------------------------------------+
//| Инициализация индикаторов |
//+------------------------------------------------------------------+
bool CFeatureEngine::InitIndicators()
{
string symbol = _Symbol;
ENUM_TIMEFRAMES period = PERIOD_CURRENT;

m_h.rsi = iRSI(symbol, period, 14, PRICE_CLOSE);
m_h.atr = iATR(symbol, period, 14);
m_h.macd = iMACD(symbol, period, 12, 26, 9, PRICE_CLOSE);
m_h.bb = iBands(symbol, period, 20, 2.0, 0, PRICE_CLOSE);
m_h.stoch = iStochastic(symbol, period, 14, 3, 3, MODE_SMA, STO_CLOSECLOSE);

if(m_h.rsi==INVALID_HANDLE || m_h.atr==INVALID_HANDLE ||
m_h.macd==INVALID_HANDLE || m_h.bb==INVALID_HANDLE)
{
Print("❌ Критические индикаторы не созданы");
return false;
}

m_h.ema20 = iMA(symbol, period, 20, 0, MODE_EMA, PRICE_CLOSE);
m_h.ema50 = iMA(symbol, period, 50, 0, MODE_EMA, PRICE_CLOSE);
m_h.sma20 = iMA(symbol, period, 20, 0, MODE_SMA, PRICE_CLOSE);
m_h.sma50 = iMA(symbol, period, 50, 0, MODE_SMA, PRICE_CLOSE);
m_h.ema9 = iMA(symbol, period, 9, 0, MODE_EMA, PRICE_CLOSE);
m_h.ema21 = iMA(symbol, period, 21, 0, MODE_EMA, PRICE_CLOSE);
m_h.ema12 = iMA(symbol, period, 12, 0, MODE_EMA, PRICE_CLOSE);
m_h.ema26 = iMA(symbol, period, 26, 0, MODE_EMA, PRICE_CLOSE);
m_h.adx = iADX(symbol, period, 14);
m_h.cci = iCCI(symbol, period, 20, PRICE_TYPICAL);
m_h.willr = iWPR(symbol, period, 14);
m_h.obv = iOBV(symbol, period, VOLUME_TICK);
m_h.mfi = iMFI(symbol, period, 14, VOLUME_TICK);

m_htf_handle = iMA(symbol, PERIOD_H1, 20, 0, MODE_EMA, PRICE_CLOSE);
m_h4_handle = iMA(symbol, PERIOD_H4, 20, 0, MODE_EMA, PRICE_CLOSE);

Print("✅ FeatureEngine: индикаторы инициализированы");
Sleep(100);

if(!LoadHistoricalData(STARTUP_BARS_TO_LOAD))
{
Print("⚠️ Не удалось загрузить историю, работа продолжится в обычном режиме");
}

return true;
}

//+------------------------------------------------------------------+
//| Освобождение ресурсов |
//+------------------------------------------------------------------+
void CFeatureEngine::DeInit()
{
#define RELEASE(h) if(h!=INVALID_HANDLE){IndicatorRelease(h); h=INVALID_HANDLE;}
RELEASE(m_h.rsi); RELEASE(m_h.atr); RELEASE(m_h.macd); RELEASE(m_h.bb); RELEASE(m_h.stoch);
RELEASE(m_h.ema20); RELEASE(m_h.ema50); RELEASE(m_h.sma20); RELEASE(m_h.sma50);
RELEASE(m_h.ema9); RELEASE(m_h.ema21); RELEASE(m_h.ema12); RELEASE(m_h.ema26);
RELEASE(m_h.adx); RELEASE(m_h.cci); RELEASE(m_h.willr); RELEASE(m_h.obv); RELEASE(m_h.mfi);
#undef RELEASE
Print("✅ FeatureEngine: ресурсы освобождены");
}

//+------------------------------------------------------------------+
bool CFeatureEngine::EnsureSymbolAvailable(string symbol)
{
if(!SymbolSelect(symbol, true)) { PrintFormat("⚠️ Не удалось выбрать %s", symbol); return false; }
Sleep(100);
return SymbolInfoDouble(symbol, SYMBOL_BID) != 0;
}

bool CFeatureEngine::CopyIndicator(int handle, int buffer, int shift, int count, double &array[])
{
return SafeCopyBuffer(handle, buffer, shift, count, array);
}

double CFeatureEngine::ClampValue(double val)
{
if(!MathIsValidNumber(val) || val != val || MathAbs(val) > MAX_FEATURE_VALUE)
return 0.0;
return val;
}

//+------------------------------------------------------------------+
//| CalculateFeaturesForBar – вычисление 63 признаков |
//+------------------------------------------------------------------+
bool CFeatureEngine::CalculateFeaturesForBar(int shift, double &feat[])
{
MqlRates rates[1];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, 1, rates) != 1) return false;

feat[F_OPEN] = ClampValue(rates[0].open);
feat[F_HIGH] = ClampValue(rates[0].high);
feat[F_LOW] = ClampValue(rates[0].low);
feat[F_CLOSE] = ClampValue(rates[0].close);
feat[F_VOLUME] = ClampValue((double)rates[0].tick_volume);

double buf[1];

#define COPY_FEAT_SAFE(enum_name, handle, buffer_idx)
if(SafeCopyBuffer(m_h.handle, buffer_idx, shift, 1, buf))
feat[F_##enum_name] = ClampValue(buf[0]);
else
feat[F_##enum_name] = 0.0;

COPY_FEAT_SAFE(RSI, rsi, 0);
COPY_FEAT_SAFE(ATR, atr, 0);
COPY_FEAT_SAFE(MACD_MAIN, macd, 0);
COPY_FEAT_SAFE(MACD_SIGNAL, macd, 1);
COPY_FEAT_SAFE(MACD_HIST, macd, 2);
COPY_FEAT_SAFE(BB_UPPER, bb, 0);
COPY_FEAT_SAFE(BB_MIDDLE, bb, 1);
COPY_FEAT_SAFE(BB_LOWER, bb, 2);
COPY_FEAT_SAFE(STOCH_K, stoch, 0);
COPY_FEAT_SAFE(STOCH_D, stoch, 1);
COPY_FEAT_SAFE(EMA20, ema20, 0);
COPY_FEAT_SAFE(EMA50, ema50, 0);
COPY_FEAT_SAFE(SMA20, sma20, 0);
COPY_FEAT_SAFE(SMA50, sma50, 0);

if(SafeCopyBuffer(m_h.adx, 0, shift, 1, buf)) feat[F_ADX] = ClampValue(buf[0]); else feat[F_ADX] = 0.0;
if(SafeCopyBuffer(m_h.adx, 1, shift, 1, buf)) feat[F_PLUS_DI] = ClampValue(buf[0]); else feat[F_PLUS_DI] = 0.0;
if(SafeCopyBuffer(m_h.adx, 2, shift, 1, buf)) feat[F_MINUS_DI] = ClampValue(buf[0]); else feat[F_MINUS_DI] = 0.0;

COPY_FEAT_SAFE(CCI, cci, 0);
COPY_FEAT_SAFE(WILLR, willr, 0);
COPY_FEAT_SAFE(OBV, obv, 0);
COPY_FEAT_SAFE(MFI, mfi, 0);

#undef COPY_FEAT_SAFE

feat[F_BB_WIDTH] = (MathAbs(feat[F_BB_MIDDLE])>1e-10) ?
(feat[F_BB_UPPER]-feat[F_BB_LOWER])/MathMax(feat[F_BB_MIDDLE],1e-10) : 0.0;
feat[F_BB_WIDTH] = ClampValue(feat[F_BB_WIDTH]);

feat[F_VWAP] = CalculateVWAP(shift, VWAP_LOOKBACK);
feat[F_HURST_20] = CalculateHurst(shift,20);
feat[F_HURST_50] = CalculateHurst(shift,50);
feat[F_HURST_100] = CalculateHurst(shift,100);
feat[F_FVG_SIZE] = CalculateFVG(shift);
feat[F_OB_STRENGTH] = CalculateOBStrength(shift);

double ema9=0, ema21=0, ema12=0, ema26=0;
if(SafeCopyBuffer(m_h.ema9, 0, shift, 1, buf)) ema9 = ClampValue(buf[0]);
if(SafeCopyBuffer(m_h.ema21, 0, shift, 1, buf)) ema21 = ClampValue(buf[0]);
if(SafeCopyBuffer(m_h.ema12, 0, shift, 1, buf)) ema12 = ClampValue(buf[0]);
if(SafeCopyBuffer(m_h.ema26, 0, shift, 1, buf)) ema26 = ClampValue(buf[0]);

feat[F_EMA_CROSS_9_21] = (ema9>ema21)?1.0:(ema9<ema21)?-1.0:0.0;
feat[F_EMA_CROSS_12_26] = (ema12>ema26)?1.0:(ema12<ema26)?-1.0:0.0;
feat[F_EMA_CROSS_20_50] = (feat[F_EMA20]>feat[F_EMA50])?1.0:(feat[F_EMA20]<feat[F_EMA50])?-1.0:0.0;

int ma5_handle = iMA(_Symbol, PERIOD_CURRENT, 5, 0, MODE_SMA, PRICE_CLOSE);
double ma5 = 0;
if(ma5_handle != INVALID_HANDLE)
{
if(SafeCopyBuffer(ma5_handle, 0, shift, 1, buf)) ma5 = ClampValue(buf[0]);
IndicatorRelease(ma5_handle);
}
double ma20 = feat[F_SMA20];
feat[F_CHAN_UPPER] = MathMax(ma5, ma20);
feat[F_CHAN_LOWER] = MathMin(ma5, ma20);
feat[F_CHAN_WIDTH] = feat[F_CHAN_UPPER] - feat[F_CHAN_LOWER];
feat[F_CHAN_WIDTH] = ClampValue(feat[F_CHAN_WIDTH]);

MqlDateTime dt; TimeToStruct(rates[0].time, dt);
feat[F_MONTH] = (double)dt.mon;
feat[F_QUARTER] = (double)((dt.mon-1)/3+1);
feat[F_MONTH_SIN] = MathSin(2.0M_PIdt.mon/12.0);
feat[F_MONTH_COS] = MathCos(2.0M_PIdt.mon/12.0);

if(TimeCurrent() - m_corr_xag.last_update > CORR_CACHE_SECONDS)
{
m_corr_xag.value = CalculateCorrelation("XAGUSD", CORR_LOOKBACK);
m_corr_xag.symbol = "XAGUSD";
m_corr_xag.period = CORR_LOOKBACK;
m_corr_xag.last_update = TimeCurrent();
m_corr_xpt.value = CalculateCorrelation("USDCAD", CORR_LOOKBACK);
m_corr_xpt.symbol = "USDCAD";
m_corr_xpt.period = CORR_LOOKBACK;
m_corr_xpt.last_update = TimeCurrent();
m_corr_usdcnh.value = CalculateCorrelation("AUDUSD", CORR_LOOKBACK);
m_corr_usdcnh.symbol = "AUDUSD";
m_corr_usdcnh.period = CORR_LOOKBACK;
m_corr_usdcnh.last_update = TimeCurrent();
}
feat[F_CORR_XAG] = ClampValue(m_corr_xag.value);
feat[F_CORR_XPT] = ClampValue(m_corr_xpt.value);
feat[F_CORR_USDCNH] = ClampValue(m_corr_usdcnh.value);

double hist_close_arr[3];
if(CopyClose(_Symbol, PERIOD_CURRENT, shift, 3, hist_close_arr) == 3)
{
double acc = (hist_close_arr[0]-hist_close_arr[1]) - (hist_close_arr[1]-hist_close_arr[2]);
if(MathAbs(acc)>1000) acc = (acc>0)?1000:-1000;
feat[F_ACCELERATION] = ClampValue(acc);
}
else feat[F_ACCELERATION] = 0;

long vol_hist[20];
if(CopyTickVolume(_Symbol, PERIOD_CURRENT, shift, 20, vol_hist) == 20)
{
double avg_vol = 0;
for(int i=0; i<20; i++) avg_vol += (double)vol_hist[i];
avg_vol /= 20.0;
if(avg_vol > 1e-10) feat[F_OBV_NORM] = feat[F_OBV] / avg_vol;
else feat[F_OBV_NORM] = 0;
feat[F_OBV_NORM] = ClampValue(feat[F_OBV_NORM]);
}
else feat[F_OBV_NORM] = 0;

feat[F_DXY] = GetDXY();
feat[F_TNX] = GetTNX();
feat[F_NEWS_IMPACT] = GetNewsImpact();

MqlRates hist[20];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, 20, hist) == 20)
{
double ret1 = MathLog(MathMax(hist[0].close,1e-10)/MathMax(hist[1].close,1e-10));
if(MathAbs(ret1)>5.0) ret1 = (ret1>0)?5.0:-5.0;
feat[F_RET_1] = ClampValue(ret1);

double ret5 = MathLog(MathMax(hist[0].close,1e-10)/MathMax(hist[5].close,1e-10));
if(MathAbs(ret5)>5.0) ret5 = (ret5>0)?5.0:-5.0;
feat[F_RET_5] = ClampValue(ret5);

double ret20 = MathLog(MathMax(hist[0].close,1e-10)/MathMax(hist[19].close,1e-10));
if(MathAbs(ret20)>5.0) ret20 = (ret20>0)?5.0:-5.0;
feat[F_RET_20] = ClampValue(ret20);

double returns[19], mean_ret=0;
for(int i=0; i<19; i++)
{
double ret = MathLog(MathMax(hist[i].close,1e-10)/MathMax(hist[i+1].close,1e-10));
if(MathAbs(ret)>5.0) ret = (ret>0)?5.0:-5.0;
returns[i] = ClampValue(ret);
mean_ret += returns[i];
}
mean_ret /= 19.0;

double variance=0; for(int i=0; i<19; i++) variance += MathPow(returns[i]-mean_ret,2); variance /= 19.0;
double vol = MathSqrt(variance);
feat[F_VOLATILITY_20] = ClampValue(vol);

if(feat[F_VOLATILITY_20] > 1e-6)
{
double skew_num=0, kurt_num=0;
for(int i=0; i<19; i++)
{
double z = (returns[i]-mean_ret)/feat[F_VOLATILITY_20];
if(MathAbs(z)>10.0) z = (z>0)?10.0:-10.0;
skew_num += MathPow(z,3);
kurt_num += MathPow(z,4);
}
feat[F_SKEW_20] = ClampValue(skew_num/19.0);
feat[F_KURTOSIS_20] = ClampValue(kurt_num/19.0 - 3.0);
}
else { feat[F_SKEW_20]=0; feat[F_KURTOSIS_20]=0; }

double bb_range = feat[F_BB_UPPER] - feat[F_BB_LOWER];
feat[F_PRICE_POS_BB] = (bb_range>1e-10) ? (feat[F_CLOSE]-feat[F_BB_LOWER])/bb_range : 0.5;
feat[F_PRICE_POS_BB] = ClampValue(feat[F_PRICE_POS_BB]);
}
else
{
feat[F_RET_1]=feat[F_RET_5]=feat[F_RET_20]=0;
feat[F_VOLATILITY_20]=feat[F_SKEW_20]=feat[F_KURTOSIS_20]=0;
feat[F_PRICE_POS_BB]=0.5;
}

MqlRates vol_hist5[5];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, 5, vol_hist5) == 5)
{
double avg_vol = ((double)vol_hist5[1].tick_volume + (double)vol_hist5[2].tick_volume +
(double)vol_hist5[3].tick_volume + (double)vol_hist5[4].tick_volume) / 4.0;
feat[F_VOL_RATIO] = (avg_vol>1e-10) ? (double)vol_hist5[0].tick_volume / avg_vol : 1.0;
feat[F_VOL_RATIO] = ClampValue(feat[F_VOL_RATIO]);

if(vol_hist5[1].tick_volume != 0)
feat[F_VOL_CHANGE] = ((double)vol_hist5[0].tick_volume - (double)vol_hist5[1].tick_volume) / (double)vol_hist5[1].tick_volume;
else feat[F_VOL_CHANGE] = 0.0;
feat[F_VOL_CHANGE] = ClampValue(feat[F_VOL_CHANGE]);
}
else { feat[F_VOL_RATIO]=1.0; feat[F_VOL_CHANGE]=0.0; }

if(rates[0].high > rates[0].low)
{
double clv = ((rates[0].close - rates[0].low) - (rates[0].high - rates[0].close)) / (rates[0].high - rates[0].low);
feat[F_ACCUM_DIST] = clv * (double)rates[0].tick_volume;
feat[F_ACCUM_DIST] = ClampValue(feat[F_ACCUM_DIST]);
}
else feat[F_ACCUM_DIST] = 0.0;

bool bad_found = false;
for(int i=0; i<FEATURE_COUNT; i++)
{
if(!MathIsValidNumber(feat[i]) || feat[i]!=feat[i] || MathAbs(feat[i]) > MAX_FEATURE_VALUE)
{
feat[i] = 0.0;
bad_found = true;
}
}

if(m_params_loaded)
for(int i=0; i<FEATURE_COUNT; i++)
NormalizeFeature(feat[i], i);

return true;
}

//+------------------------------------------------------------------+
//| ✅ GetModelInputs – 4 параметра (LSTM, STCA, OneTrans, flat) |
//+------------------------------------------------------------------+
bool CFeatureEngine::GetModelInputs(double &lstm_input[], double &trans_input[], double &onetrans_input[], double &flat_input[])
{
if(!IsReady())
{
if(m_verbose) Print("❌ GetModelInputs: система не готова");
return false;
}

int cache_size = ArrayRange(m_cache, 0);
if(cache_size <= 0)
{
Print("❌ GetModelInputs: m_cache пуст");
return false;
}

int available = MathMin(m_cached_bars, cache_size);
if(available < TRANSFORMER_LOOKBACK)
{
Print("⏳ Недостаточно баров: ", available, " < ", TRANSFORMER_LOOKBACK);
return false;
}

const int lstm_size = LSTM_LOOKBACK * FEATURE_COUNT;
const int trans_size = TRANSFORMER_LOOKBACK * FEATURE_COUNT;
const int onetrans_size = trans_size;
const int flat_size = FEATURE_COUNT;

ArrayResize(lstm_input, lstm_size);
ArrayResize(trans_input, trans_size);
ArrayResize(onetrans_input, onetrans_size);
ArrayResize(flat_input, flat_size);

ArrayInitialize(lstm_input, 0.0);
ArrayInitialize(trans_input, 0.0);
ArrayInitialize(onetrans_input, 0.0);
ArrayInitialize(flat_input, 0.0);

const int start_idx = MathMax(0, available - TRANSFORMER_LOOKBACK);

for(int i=0; i<TRANSFORMER_LOOKBACK; i++)
{
const int cache_idx = start_idx + i;
if(cache_idx < 0 || cache_idx >= available || cache_idx >= cache_size) continue;

for(int j=0; j<FEATURE_COUNT; j++)
{
double val = m_cache[cache_idx][j];
if(!MathIsValidNumber(val) || MathAbs(val) > MAX_FEATURE_VALUE) val = 0.0;
const double dval = MathMax(-10.0, MathMin(10.0, val));

const int trans_index = i * FEATURE_COUNT + j;
if(trans_index < trans_size)
{
trans_input[trans_index] = dval;
onetrans_input[trans_index] = dval;
}

if(i >= TRANSFORMER_LOOKBACK - LSTM_LOOKBACK)
{
const int lstm_rel = i - (TRANSFORMER_LOOKBACK - LSTM_LOOKBACK);
if(lstm_rel >= 0 && lstm_rel < LSTM_LOOKBACK)
{
const int lstm_index = lstm_rel * FEATURE_COUNT + j;
if(lstm_index < lstm_size)
lstm_input[lstm_index] = dval;
}
}

if(i == TRANSFORMER_LOOKBACK - 1 && j < flat_size)
flat_input[j] = dval;
}
}

if(ArraySize(lstm_input)!=lstm_size || ArraySize(trans_input)!=trans_size ||
ArraySize(onetrans_input)!=onetrans_size || ArraySize(flat_input)!=flat_size)
{
Print("❌ Size mismatch in GetModelInputs");
return false;
}

return true;
}

//+------------------------------------------------------------------+
//| Update – обновление кэша |
//+------------------------------------------------------------------+
bool CFeatureEngine::Update()
{
datetime cur_bar = iTime(_Symbol, PERIOD_CURRENT, 0);
if(cur_bar == m_last_bar_time) return true;

UpdateHTFData();

int available_bars = Bars(_Symbol, PERIOD_CURRENT);
if(available_bars < MIN_BARS_REQUIRED) return false;

int cache_bars = ArrayRange(m_cache, 0);

if(m_cached_bars >= HISTORY_BARS_MAX)
{
for(int i=1; i<HISTORY_BARS_MAX; i++)
for(int j=0; j<FEATURE_COUNT; j++)
m_cache[i-1][j] = m_cache[i][j];
m_cached_bars = HISTORY_BARS_MAX;
}
else
{
int new_size = m_cached_bars + 1;
if(new_size > cache_bars)
{
if(!ArrayResize(m_cache, new_size, FEATURE_COUNT)) return false;
}
m_cached_bars = new_size;
}

double feat[FEATURE_COUNT];
if(!CalculateFeaturesForBar(0, feat)) return false;

int target_idx = m_cached_bars - 1;
if(target_idx < 0 || target_idx >= ArrayRange(m_cache, 0)) return false;

for(int j=0; j<FEATURE_COUNT; j++)
m_cache[target_idx][j] = feat[j];

m_last_bar_time = cur_bar;
UpdateRegimeThresholds();
return true;
}

bool CFeatureEngine::GetCurrentFeatures(double &feat[])
{
if(!Update()) return false;
if(m_cached_bars == 0) return false;
int cache_bars = ArrayRange(m_cache, 0);
if(cache_bars == 0) return false;
int last_idx = MathMin(m_cached_bars, cache_bars) - 1;
if(last_idx < 0 || last_idx >= cache_bars) return false;
for(int i=0; i<FEATURE_COUNT; i++)
feat[i] = m_cache[last_idx][i];
return true;
}

//+------------------------------------------------------------------+
//| Вспомогательные методы (сокращённо) |
//+------------------------------------------------------------------+
double CFeatureEngine::CalculateVWAP(int shift, int lookback)
{
MqlRates rates[];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, lookback, rates) != lookback) return 0.0;
double cum_pv=0, cum_v=0;
for(int i=0; i<lookback; i++)
{
double tp = (rates[i].high + rates[i].low + rates[i].close)/3.0;
cum_pv += tp * (double)rates[i].tick_volume;
cum_v += (double)rates[i].tick_volume;
}
return ClampValue((cum_v > 1e-10) ? cum_pv / cum_v : rates[0].close);
}

double CFeatureEngine::CalculateHurst(int shift, int period)
{
if(period < 10) return 0.5;
MqlRates rates[];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, period+1, rates) != period+1) return 0.5;
double returns[]; ArrayResize(returns, period);
for(int i=0; i<period; i++)
returns[i] = (rates[i+1].close>0) ? MathLog(rates[i].close / rates[i+1].close) : 0;
double mean=0; for(int i=0; i<period; i++) mean+=returns[i]; mean/=period;
double cum_dev=0, max_cum=-1e30, min_cum=1e30;
for(int i=0; i<period; i++) { cum_dev += returns[i] - mean; if(cum_dev > max_cum) max_cum = cum_dev; if(cum_dev < min_cum) min_cum = cum_dev; }
double range = max_cum - min_cum;
if(range < 1e-10) return 0.5;
double std_dev=0; for(int i=0; i<period; i++) std_dev += MathPow(returns[i]-mean,2);
std_dev = MathSqrt(std_dev/period);
if(std_dev < 1e-10) return 0.5;
double rs = range / std_dev;
double H = 0.5 + MathLog(rs) / (2.0 * MathLog((double)period));
return ClampValue(MathMax(0.0, MathMin(1.0, H)));
}

double CFeatureEngine::CalculateFVG(int shift)
{
MqlRates rates[3];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, 3, rates) != 3) return 0.0;
if(rates[0].low > rates[2].high && rates[0].close>0) return ClampValue((rates[0].low - rates[2].high) / rates[0].close);
if(rates[0].high < rates[2].low && rates[0].close>0) return ClampValue((rates[2].low - rates[0].high) / rates[0].close);
return 0.0;
}

double CFeatureEngine::CalculateOBStrength(int shift)
{
MqlRates rates[5];
if(CopyRates(_Symbol, PERIOD_CURRENT, shift, 5, rates) != 5) return 0.0;
double max_range=0; int impulse_idx=-1;
for(int i=0; i<4; i++) { double range = rates[i].high - rates[i].low; double body = MathAbs(rates[i].close - rates[i].open); if(range>0 && body>range*0.7 && range>max_range) { max_range=range; impulse_idx=i; } }
if(impulse_idx<0) return 0.0;
double consolidation=0; int consol_count=0;
for(int i=impulse_idx+1; i<4; i++) { consolidation += rates[i].high - rates[i].low; consol_count++; }
if(consol_count==0) return 0.0;
consolidation /= consol_count;
return ClampValue((consolidation>1e-10) ? MathMin(1.0, max_range/consolidation) : 0.0);
}

double CFeatureEngine::CalculateCorrelation(string symbol, int period)
{
if(period < 20) return 0.0;
if(!EnsureSymbolAvailable(symbol)) return 0.0;
datetime now = TimeCurrent();
if(symbol == "XAGUSD" && now - m_corr_xag.last_update < CORR_CACHE_SECONDS) return ClampValue(m_corr_xag.value);
if(symbol == "USDCAD" && now - m_corr_xpt.last_update < CORR_CACHE_SECONDS) return ClampValue(m_corr_xpt.value);
if(symbol == "AUDUSD" && now - m_corr_usdcnh.last_update < CORR_CACHE_SECONDS) return ClampValue(m_corr_usdcnh.value);
double x[], y[]; ArrayResize(x, period); ArrayResize(y, period);
MqlRates base_rates[], corr_rates[];
if(CopyRates(_Symbol, PERIOD_CURRENT, 1, period, base_rates) != period) return 0.0;
if(CopyRates(symbol, PERIOD_CURRENT, 1, period, corr_rates) != period) return 0.0;
for(int i=0; i<period; i++) { x[i] = base_rates[i].close; y[i] = corr_rates[i].close; }
double sum_x=0, sum_y=0, sum_xy=0, sum_x2=0, sum_y2=0;
for(int i=0; i<period; i++) { sum_x+=x[i]; sum_y+=y[i]; sum_xy+=x[i]y[i]; sum_x2+=x[i]x[i]; sum_y2+=y[i]y[i]; }
double numerator = periodsum_xy - sum_xsum_y;
double var_x = periodsum_x2 - sum_xsum_x;
double var_y = periodsum_y2 - sum_y*sum_y;
if(var_x < 1e-10 || var_y < 1e-10) return 0.0;
double denominator = MathSqrt(var_x * var_y);
if(denominator < 1e-10) return 0.0;
double result = ClampValue(MathMax(-1.0, MathMin(1.0, numerator / denominator)));
if(symbol == "XAGUSD") { m_corr_xag.value = result; m_corr_xag.last_update = now; }
else if(symbol == "USDCAD") { m_corr_xpt.value = result; m_corr_xpt.last_update = now; }
else if(symbol == "AUDUSD") { m_corr_usdcnh.value = result; m_corr_usdcnh.last_update = now; }
return result;
}

double CFeatureEngine::GetDXY()
{
datetime now = TimeCurrent();
if(now - m_macro.last_update < MACRO_CACHE_SECONDS) return ClampValue(m_macro.dxy);
struct CurrencyWeight { string symbol; double weight; };
CurrencyWeight currencies[] = {{"EURUSD", -0.576}, {"USDJPY", 0.136}, {"GBPUSD", -0.119}, {"USDCAD", 0.091}, {"USDCHF", 0.036}};
double dxy = 50.14348112;
bool all_ok = true;
for(int i=0; i<ArraySize(currencies); i++) { if(!EnsureSymbolAvailable(currencies[i].symbol)) { all_ok=false; break; } double price = SymbolInfoDouble(currencies[i].symbol, SYMBOL_BID); if(price <= 0 || !MathIsValidNumber(price)) { all_ok=false; break; } dxy *= MathPow(price, currencies[i].weight); }
if(!all_ok || dxy <= 0 || !MathIsValidNumber(dxy)) { double gold = SymbolInfoDouble(_Symbol, SYMBOL_BID); if(gold > 1000 && gold < 3000 && MathIsValidNumber(gold)) m_macro.dxy = MathMax(80.0, MathMin(120.0, 120.0 - gold / 20.0)); else m_macro.dxy = 100.0; } else m_macro.dxy = dxy;
m_macro.dxy = ClampValue(m_macro.dxy);
if(!MathIsValidNumber(m_macro.dxy)) m_macro.dxy = 100.0;
m_macro.last_update = now;
return m_macro.dxy;
}

double CFeatureEngine::GetTNX()
{
datetime now = TimeCurrent();
if(now - m_macro.last_update < MACRO_CACHE_SECONDS) return ClampValue(m_macro.tnx);
string tnx_symbols[] = {"US10Y", "TNX", "ZN", "T-Note"};
bool found = false; double tnx = 0;
for(int i=0; i<ArraySize(tnx_symbols); i++) { if(EnsureSymbolAvailable(tnx_symbols[i])) { double price = SymbolInfoDouble(tnx_symbols[i], SYMBOL_BID); if(price > 0 && price < 200 && MathIsValidNumber(price)) { if(StringFind(tnx_symbols[i], "US10Y") >= 0) tnx = price; else tnx = MathMax(1.0, MathMin(15.0, 100.0 - price)); found = true; break; } } }
if(!found) { double gold = SymbolInfoDouble(_Symbol, SYMBOL_BID); if(gold > 1500 && gold < 3000 && MathIsValidNumber(gold)) tnx = MathMax(2.0, MathMin(8.0, 10.0 - (gold - 2000) / 200.0)); else tnx = 4.0; }
m_macro.tnx = ClampValue(tnx);
if(!MathIsValidNumber(m_macro.tnx)) m_macro.tnx = 4.0;
m_macro.last_update = now;
return m_macro.tnx;
}

string CFeatureEngine::GetEventCurrency(ulong event_id) { MqlCalendarEvent event; if(!CalendarEventById(event_id, event)) return ""; MqlCalendarCountry country; if(!CalendarCountryById(event.country_id, country)) return ""; return country.currency; }
bool CFeatureEngine::IsImportantEvent(ulong event_id) { MqlCalendarEvent event; if(!CalendarEventById(event_id, event)) return false; if(GetEventCurrency(event_id) != "USD") return false; if(event.importance < 2) return false; return true; }

double CFeatureEngine::CalculateNewsImpact()
{
datetime now = TimeCurrent();
datetime from = now - 606024*7;
datetime to = now;
MqlCalendarValue values[];
if(!CalendarValueHistory(values, from, to, NULL, NULL)) return (m_macro.last_news_time==0) ? 0.0 : m_macro.news_impact;
double total=0; int count=0; datetime last_t=0; ulong last_id=0; bool new_events=false;
for(int i=0; i<ArraySize(values); i++)
{
if(values[i].id == m_macro.last_news_id && values[i].time <= m_macro.last_news_time) continue;
if(!IsImportantEvent(values[i].event_id)) continue;
double impact = 0.0;
if(values[i].HasActualValue() && values[i].HasForecastValue()) { double act = values[i].GetActualValue(); double fct = values[i].GetForecastValue(); if(fct != 0) impact = (act - fct) / fct; else if(values[i].HasPreviousValue()) impact = (act - values[i].GetPreviousValue()) / values[i].GetPreviousValue(); }
else if(values[i].HasActualValue() && values[i].HasPreviousValue()) impact = (values[i].GetActualValue() - values[i].GetPreviousValue()) / values[i].GetPreviousValue();
MqlCalendarEvent ev; if(CalendarEventById(values[i].event_id, ev)) { if(ev.importance == 3) impact *= 1.0; else if(ev.importance == 2) impact *= 0.5; else impact *= 0.2; }
impact = MathMax(-1.0, MathMin(1.0, impact));
total += impact; count++; new_events = true;
if(values[i].time > last_t) { last_t = values[i].time; last_id = values[i].id; }
}
if(new_events && count>0) { m_macro.last_news_time = last_t; m_macro.last_news_id = last_id; m_macro.news_prev_impact = m_macro.news_impact; m_macro.news_impact = total / count; }
return m_macro.news_impact;
}

double CFeatureEngine::GetNewsImpact()
{
datetime now = TimeCurrent();
if(now - m_macro.last_update < NEWS_CACHE_SECONDS) return ClampValue(m_macro.news_impact);
m_macro.news_impact = CalculateNewsImpact();
m_macro.last_update = now;
return ClampValue(m_macro.news_impact);
}

void CFeatureEngine::NormalizeFeature(double &value, int idx)
{
if(idx<0 || idx>=FEATURE_COUNT) return;
if(m_scale[idx] < 1e-10 || !MathIsValidNumber(m_scale[idx])) { m_scale[idx] = 1.0; return; }
if(!MathIsValidNumber(m_mean[idx])) m_mean[idx] = 0.0;
if(!MathIsValidNumber(value) || value != value || MathAbs(value) > MAX_FEATURE_VALUE) { value = 0.0; return; }
value = (value - m_mean[idx]) / m_scale[idx];
value = MathMax(-10.0, MathMin(10.0, value));
if(!MathIsValidNumber(value)) value = 0.0;
}

double CFeatureEngine::SoftThreshold(double x, double thr) { if(x > thr) return x - thr; if(x < -thr) return x + thr; return 0.0; }
double CFeatureEngine::EstimateNoiseLevel(const double &detail[]) { int n = ArraySize(detail); double temp[]; ArrayCopy(temp, detail); for(int i=0; i<n; i++) temp[i] = fabs(temp[i]); ArraySort(temp); double median = (n%2==0) ? (temp[n/2-1]+temp[n/2])/2 : temp[n/2]; return median / 0.6745; }
void CFeatureEngine::WaveletDecompose(const double &input_array[], int level, double &output[]) { int n = ArraySize(input_array); if(n < 2 || level <= 0) { ArrayCopy(output, input_array); return; } double approx[], detail[]; int m = n/2; ArrayResize(approx, m); ArrayResize(detail, m); for(int i=0; i<m; i++) { approx[i] = (input_array[2i] + input_array[2i+1]) / 2.0; detail[i] = (input_array[2i] - input_array[2i+1]) / 2.0; } double approx_decomp[]; WaveletDecompose(approx, level-1, approx_decomp); int approx_size = ArraySize(approx_decomp); ArrayResize(output, approx_size + m); for(int i=0; i<m; i++) output[i] = detail[i]; for(int i=0; i<approx_size; i++) output[m + i] = approx_decomp[i]; }
double CFeatureEngine::GetWaveletDenoised(int shift) { int window = 32; if(m_cached_bars < shift + window) return 0; double prices[]; ArrayResize(prices, window); for(int i=0; i<window; i++) { int idx = shift + i; if(idx >= m_cached_bars) return 0; prices[i] = m_cache[idx][F_CLOSE]; } double coeffs[]; WaveletDecompose(prices, WAVELET_LEVEL, coeffs); int n1 = window/2; double detail1[]; ArrayResize(detail1, n1); ArrayCopy(detail1, coeffs, 0, 0, n1); double sigma = EstimateNoiseLevel(detail1); double threshold = sigma * sqrt(2 * log((double)window)); for(int i=0; i<ArraySize(coeffs); i++) coeffs[i] = SoftThreshold(coeffs[i], threshold); int last_approx = ArraySize(coeffs) - 1; return ClampValue(coeffs[last_approx]); }
double CFeatureEngine::GetFractalDimension(int period) { if(m_cached_bars < period) return 1.5; double H = CalculateHurst(0, period); return 2.0 - H; }
int CFeatureEngine::GetVolatilityRegime() { int last = MathMin(m_cached_bars, HISTORY_BARS_MAX) - 1; if(last < 0) return 1; double current_atr = m_cache[last][F_ATR]; if(current_atr <= 0) return 1; if(m_vol_threshold_low == 0) UpdateRegimeThresholds(); if(current_atr < m_vol_threshold_low) return 0; else if(current_atr > m_vol_threshold_high) return 2; else return 1; }
void CFeatureEngine::UpdateRegimeThresholds() { int last = MathMin(m_cached_bars, HISTORY_BARS_MAX) - 1; if(last < 0) return; int count = MathMin(REGIME_HISTORY, last + 1); if(count < 10) return; double atr_hist[]; ArrayResize(atr_hist, count); for(int i=0; i<count; i++) atr_hist[i] = m_cache[last - i][F_ATR]; ArraySort(atr_hist); int idx33 = (int)(count * 0.33); int idx66 = (int)(count * 0.66); m_vol_threshold_low = atr_hist[idx33]; m_vol_threshold_high = atr_hist[idx66]; }
void CFeatureEngine::UpdateHTFData() { double buf[1]; if(m_htf_handle != INVALID_HANDLE && SafeCopyBuffer(m_htf_handle, 0, 0, 1, buf)) { int size = ArraySize(m_htf_cache); ArrayResize(m_htf_cache, size + 1, 1); m_htf_cache[size][0] = buf[0]; } if(m_h4_handle != INVALID_HANDLE && SafeCopyBuffer(m_h4_handle, 0, 0, 1, buf)) { int size = ArraySize(m_h4_cache); ArrayResize(m_h4_cache, size + 1, 1); m_h4_cache[size][0] = buf[0]; } }
double CFeatureEngine::GetMultiTFConvergence() { int last = MathMin(m_cached_bars, HISTORY_BARS_MAX) - 1; if(last < 0) return 0; double ema_m1 = m_cache[last][F_EMA20]; double ema_h1 = 0, ema_h4 = 0; if(ArraySize(m_htf_cache) > 0) { int last_h1 = ArraySize(m_htf_cache) - 1; ema_h1 = m_htf_cache[last_h1][0]; } if(ArraySize(m_h4_cache) > 0) { int last_h4 = ArraySize(m_h4_cache) - 1; ema_h4 = m_h4_cache[last_h4][0]; } if(ema_h1 == 0 || ema_h4 == 0) return 0; double diff_h1 = (ema_m1 - ema_h1) / ema_h1; double diff_h4 = (ema_m1 - ema_h4) / ema_h4; if(diff_h1 * diff_h4 > 0 && fabs(diff_h1) < 0.01 && fabs(diff_h4) < 0.02) return 1.0; else if(diff_h1 * diff_h4 > 0) return 0.5; else return 0.0; }
double CFeatureEngine::GetMomentumCluster() { int last = MathMin(m_cached_bars, HISTORY_BARS_MAX) - 1; if(last < 0) return 0; double rsi = m_cache[last][F_RSI]; double roc = m_cache[last][F_RET_1]; if(rsi > 70 && roc > 0) return 2.0; else if(rsi > 60 && roc > 0) return 1.0; else if(rsi < 30 && roc < 0) return -2.0; else if(rsi < 40 && roc < 0) return -1.0; else return 0.0; }
void CFeatureEngine::RecordMacroFactors() { datetime now = TimeCurrent(); m_macro_history[m_macro_history_index].time = now; m_macro_history[m_macro_history_index].dxy = GetDXY(); m_macro_history[m_macro_history_index].tnx = GetTNX(); m_macro_history[m_macro_history_index].news = GetNewsImpact(); m_macro_history_index++; if(m_macro_history_index >= MACRO_HISTORY_SIZE) m_macro_history_index = 0; if(m_macro_history_count < MACRO_HISTORY_SIZE) m_macro_history_count++; }
double CFeatureEngine::GetBayesianTrendProb() { double prior_mean = m_bayes_alpha / (m_bayes_alpha + m_bayes_beta); double dxy = GetDXY(); double tnx = GetTNX(); double news = GetNewsImpact(); double dxy_norm = 1.0 - MathAbs(dxy - 100.0) / 20.0; if(dxy_norm < 0) dxy_norm = 0; if(dxy_norm > 1) dxy_norm = 1; double tnx_norm = 1.0 - tnx / 10.0; if(tnx_norm < 0) tnx_norm = 0; if(tnx_norm > 1) tnx_norm = 1; double news_norm = (news + 1.0) / 2.0; double likelihood = (dxy_norm + tnx_norm + news_norm) / 3.0; double new_alpha = m_bayes_alpha + likelihood; double new_beta = m_bayes_beta + (1.0 - likelihood); double posterior = new_alpha / (new_alpha + new_beta); m_last_bayes_prob = posterior; return posterior; }
void CFeatureEngine::UpdateBayesWithTradeOutcome(double profit) { int success = (profit > 0) ? 1 : 0; m_bayes_alpha += success; m_bayes_beta += (1 - success); }
double CFeatureEngine::GetPolygonalMA(int shift, int period, int poly) { if(period < 2) return 0; double prices[]; if(CopyClose(_Symbol, PERIOD_CURRENT, shift, period, prices) != period) return 0; ArraySetAsSeries(prices, true); double weights[]; ArrayResize(weights, period); double sumWeights = 0; for(int i=0; i<period; i++) { int n = period - i; double w = 1.0; if(poly > 0) { w = 1.0; for(int k=1; k<=poly; k++) w = (double)(n + k - 1) / (double)k; } weights[i] = w; sumWeights += w; } if(sumWeights > 1e-10) for(int i=0; i<period; i++) weights[i] /= sumWeights; double result = 0; for(int i=0; i<period; i++) result += prices[i] * weights[i]; return ClampValue(result); }
double CFeatureEngine::GetLiquidityDistance(int shift, double &strength) { strength = 0; int lookback = 100; if(lookback < 10) return 0; MqlRates rates[]; if(CopyRates(_Symbol, PERIOD_CURRENT, shift, lookback, rates) != lookback) return 0; ArraySetAsSeries(rates, true); double currentClose = rates[0].close; double minDist = 1e10; int touches = 0; for(int i=2; i<lookback-2; i++) { if(rates[i].high > rates[i-1].high && rates[i].high > rates[i+1].high && rates[i].high > rates[i-2].high && rates[i].high > rates[i+2].high) { double dist = MathAbs(currentClose - rates[i].high); if(dist < minDist) { minDist = dist; for(int j=i+1; j<lookback; j++) if(rates[j].high >= rates[i].high0.999 && rates[j].high <= rates[i].high1.001) touches++; strength = (double)touches / 10.0; } } if(rates[i].low < rates[i-1].low && rates[i].low < rates[i+1].low && rates[i].low < rates[i-2].low && rates[i].low < rates[i+2].low) { double dist = MathAbs(currentClose - rates[i].low); if(dist < minDist) { minDist = dist; for(int j=i+1; j<lookback; j++) if(rates[j].low >= rates[i].low0.999 && rates[j].low <= rates[i].low*1.001) touches++; strength = (double)touches / 10.0; } } } double result = (minDist < 1e10) ? minDist / _Point : 0; strength = ClampValue(strength); return ClampValue(result); }
double CFeatureEngine::GetStopHuntProbability() { int lookback_shadows = 10; int lookback_levels = 20; if(m_cached_bars < lookback_levels) return 0.0; int last_idx = MathMin(m_cached_bars, HISTORY_BARS_MAX) - 1; if(last_idx < 0) return 0.0; double max_prob = 0.0; double recent_high = -1e10, recent_low = 1e10; for(int i = 1; i <= lookback_levels; i++) { int idx = last_idx - i; if(idx < 0) break; if(m_cache[idx][F_HIGH] > recent_high) recent_high = m_cache[idx][F_HIGH]; if(m_cache[idx][F_LOW] < recent_low) recent_low = m_cache[idx][F_LOW]; } double atr_sum = 0; for(int i = 0; i < lookback_shadows; i++) { int idx = last_idx - i; if(idx < 0) break; atr_sum += m_cache[idx][F_ATR]; } double avg_atr = (lookback_shadows > 0) ? atr_sum / lookback_shadows : 1.0; if(avg_atr < 1e-10) return 0.0; for(int i = 0; i < lookback_shadows; i++) { int idx = last_idx - i; if(idx < 1) break; double open = m_cache[idx][F_OPEN]; double high = m_cache[idx][F_HIGH]; double low = m_cache[idx][F_LOW]; double close = m_cache[idx][F_CLOSE]; double vol = m_cache[idx][F_VOLUME]; double obv = m_cache[idx][F_OBV]; double body = MathAbs(close - open); double upper_shadow = high - MathMax(open, close); double lower_shadow = MathMin(open, close) - low; double range = high - low; if(range < 1e-10) continue; bool long_upper = (upper_shadow > 1.5 * body) && (upper_shadow > 0.3 * avg_atr); bool long_lower = (lower_shadow > 1.5 * body) && (lower_shadow > 0.3 * avg_atr); if(!long_upper && !long_lower) continue; bool touched_resistance = long_upper && (high >= recent_high); bool touched_support = long_lower && (low <= recent_low); if(!touched_resistance && !touched_support) continue; double prev_vol = m_cache[idx+1][F_VOLUME]; double vol_ratio = (prev_vol > 0) ? vol / prev_vol : 1.0; bool high_volume = vol_ratio > 1.5; double prev_obv = m_cache[idx+1][F_OBV]; bool obv_divergence = false; if(prev_obv != 0) { if(touched_resistance && close < open) obv_divergence = (obv < prev_obv); if(touched_support && close > open) obv_divergence = (obv > prev_obv); } double prob = 0.0; prob += (touched_resistance || touched_support) ? 0.3 : 0.0; prob += ( (upper_shadow + lower_shadow) / avg_atr ) * 0.3; if(high_volume) prob += 0.2; if(obv_divergence) prob += 0.2; prob = MathMin(1.0, prob); if(prob > max_prob) max_prob = prob; } return ClampValue(max_prob); }

//+------------------------------------------------------------------+
//| Контекстные методы |
//+------------------------------------------------------------------+
bool CFeatureEngine::UpdateContextCache()
{
datetime now = TimeCurrent();
if(now - m_context.last_update < 5) return true;
m_context.positions_count = (double)PositionsTotal();
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
m_context.pnl = equity - balance;
m_context.equity_ratio = (balance > 0) ? equity / balance : 1.0;
double margin = AccountInfoDouble(ACCOUNT_MARGIN);
m_context.margin_usage = (balance > 0) ? margin / balance : 0.0;
double total_volume = 0; int win_cnt = 0, lose_cnt = 0; double total_duration = 0;
for(int i = PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); if(PositionSelectByTicket(ticket)) { if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == m_magic_number) { total_volume += PositionGetDouble(POSITION_VOLUME); datetime open_time = (datetime)PositionGetInteger(POSITION_TIME); double profit = PositionGetDouble(POSITION_PROFIT); if(profit > 0) win_cnt++; else if(profit < 0) lose_cnt++; total_duration += (double)(now - open_time); } } }
m_context.open_volume = total_volume;
m_context.winning_rate_short = (win_cnt + lose_cnt > 0) ? (double)win_cnt / (win_cnt + lose_cnt) : 0.5;
m_context.avg_trade_duration = (win_cnt + lose_cnt > 0) ? total_duration / (win_cnt + lose_cnt) : 0;
m_context.last_update = now;
m_context_valid = true;
return true;
}

bool CFeatureEngine::GetContextFeatures(double &context[], int &size)
{
if(!m_context_valid) UpdateContextCache();
size = CONTEXT_DIM;
ArrayResize(context, size);
context[0] = m_context.positions_count;
context[1] = m_context.pnl;
context[2] = m_context.equity_ratio;
context[3] = m_context.margin_usage;
context[4] = m_context.open_volume;
context[5] = m_context.winning_rate_short;
context[6] = m_context.avg_trade_duration;
for(int i=7; i<size; i++) context[i] = 0;
return true;
}

int CFeatureEngine::GetRSIConvergence(double ob_level, double os_level, int &count_ob, int &count_os)
{
ENUM_TIMEFRAMES tfs[] = {PERIOD_M1, PERIOD_M5, PERIOD_M15, PERIOD_M30, PERIOD_H1, PERIOD_H4, PERIOD_D1};
count_ob = 0; count_os = 0;
for(int i=0; i<ArraySize(tfs); i++) { int handle = iRSI(_Symbol, tfs[i], 14, PRICE_CLOSE); if(handle == INVALID_HANDLE) continue; double rsi[1]; if(SafeCopyBuffer(handle, 0, 0, 1, rsi)) { if(rsi[0] >= ob_level) count_ob++; else if(rsi[0] <= os_level) count_os++; } IndicatorRelease(handle); }
return (count_ob >= count_os) ? count_ob : -count_os;
}

bool CFeatureEngine::IndicatorCheckValid(int handle)
{
if(handle == INVALID_HANDLE) return false;
double test_buf[1];
ArrayInitialize(test_buf, 0.0);
int copied = CopyBuffer(handle, 0, 1, 1, test_buf);
return (copied == 1 && MathIsValidNumber(test_buf[0]));
}

bool CFeatureEngine::GetBOSCHoCHSignals(int &bos_signal, int &choch_signal)
{
bos_signal = 0; choch_signal = 0;
if(m_zigzag_handle != INVALID_HANDLE) { if(TimeCurrent() - m_zigzag_created_time < ZIGZAG_INIT_DELAY) { if(m_verbose) Print("⏳ ZigZag ещё не готов"); return false; } }
if(m_zigzag_handle == INVALID_HANDLE) { m_zigzag_handle = iCustom(_Symbol, PERIOD_CURRENT, "ZigZag_BOS_CHoCH_Buffers", 512, 12, 5, 3); if(m_zigzag_handle == INVALID_HANDLE) { if(m_verbose) Print("⚠️ ZigZag handle не создан"); return false; } m_zigzag_created_time = TimeCurrent(); if(m_verbose) Print("🔧 ZigZag создан"); return false; }
if(!IndicatorCheckValid(m_zigzag_handle)) { if(m_verbose) Print("⚠️ ZigZag handle невалиден"); m_zigzag_handle = INVALID_HANDLE; return false; }
double bos_buf[1], choch_buf[1];
if(SafeCopyBuffer(m_zigzag_handle, 3, 0, 1, bos_buf)) if(MathAbs(bos_buf[0]) > 1e-10) bos_signal = (int)bos_buf[0];
if(SafeCopyBuffer(m_zigzag_handle, 4, 0, 1, choch_buf)) if(MathAbs(choch_buf[0]) > 1e-10) choch_signal = (int)choch_buf[0];
return true;
}

bool CFeatureEngine::UpdateStrategyWeights()
{
datetime now = TimeCurrent();
if(now - m_last_weight_update < STRATEGY_WEIGHT_UPDATE_HOURS * 3600) return true;
double total = 0;
for(int i=0; i<3; i++) { double acc = (m_model_total[i] > 0) ? (double)m_model_correct[i] / m_model_total[i] : 0.5; m_strategy_weights[i] = MathMax(0.05, acc); total += m_strategy_weights[i]; }
if(total > 0) for(int i=0; i<3; i++) m_strategy_weights[i] /= total;
m_last_weight_update = now;
return true;
}

void CFeatureEngine::GetStrategyWeights(double &weights[])
{
if(ArraySize(weights) < 3) ArrayResize(weights, 3);
if(m_last_weight_update == 0) UpdateStrategyWeights();
weights[0] = m_strategy_weights[0];
weights[1] = m_strategy_weights[1];
weights[2] = m_strategy_weights[2];
}
2026.03.31 11:19:41.954 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🚀 XAUUSD AI EA v7.0 инициализация...
2026.03.31 11:19:41.954 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🔍 Система: CPU=12 ядер, RAM=16263 MB
2026.03.31 11:19:41.954 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ Параметры нормализации загружены
2026.03.31 11:19:41.954 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ FeatureEngine: загружено 63 параметров
2026.03.31 11:19:41.955 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ FeatureEngine: индикаторы инициализированы
2026.03.31 11:19:42.073 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📥 Загрузка истории: 250 баров...
2026.03.31 11:20:05.793 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ История загружена: 200 баров, последний: 2026.03.31 09:19
2026.03.31 11:20:05.793 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🧠 ONNX режим: CPU
2026.03.31 11:20:05.793 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🔍 Система: CPU=12 ядер, RAM=16263 MB
2026.03.31 11:20:07.171 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ONNX: CPU selected
2026.03.31 11:20:07.171 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ LSTM загружена
2026.03.31 11:20:07.232 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ONNX: CPU selected
2026.03.31 11:20:07.232 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ STCA загружена
2026.03.31 11:20:07.281 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ONNX: CPU selected
2026.03.31 11:20:07.281 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ OneTrans загружена
2026.03.31 11:20:07.281 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ ONNX модели настроены (LSTM + STCA + OneTrans)
2026.03.31 11:20:07.307 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ Инициализация завершена
2026.03.31 11:20:07.307 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Настройки торговли: Enabled=true Disable=false
2026.03.31 11:20:07.307 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Фильтры: BOS=true H1=true RSI=true
2026.03.31 11:20:07.307 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Порог уверенности: 0.5
2026.03.31 11:20:09.649 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🔧 ZigZag создан
2026.03.31 11:20:10.417 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ❌ LSTM OnnxRun error: 4806
2026.03.31 11:20:10.417 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ⚠️ Не удалось получить прогнозы моделей

исправить ошибку

изменения внесены но ошибка сохраняется
2026.03.31 12:04:26.643 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ LSTM загружена
2026.03.31 12:04:26.701 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ONNX: CPU selected
2026.03.31 12:04:26.701 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ STCA загружена
2026.03.31 12:04:26.745 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ONNX: CPU selected
2026.03.31 12:04:26.745 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ OneTrans загружена
2026.03.31 12:04:26.745 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ ONNX модели настроены (LSTM + STCA + OneTrans)
2026.03.31 12:04:26.762 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ✅ Инициализация завершена
2026.03.31 12:04:26.762 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Настройки торговли: Enabled=true Disable=false
2026.03.31 12:04:26.762 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Фильтры: BOS=true H1=true RSI=true
2026.03.31 12:04:26.762 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 📊 Порог уверенности: 0.5
2026.03.31 12:04:28.792 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) 🔧 ZigZag создан
2026.03.31 12:04:29.464 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ❌ LSTM OnnxRun error: 4806 (outputs=1)
2026.03.31 12:04:29.464 XAUUSD_AI_EA_v7.0 (XAUUSD,M1) ⚠️ Не удалось получить прогнозы моделей