//+------------------------------------------------------------------+
//|                                            BrainRL_Expert_v2.mq5 |
//|                        Самообучающаяся система на базе RL        |
//|                                      Copyright 2025, BrainRL     |
//+------------------------------------------------------------------+
#property copyright "BrainRL Expert v2.0"
#property version   "2.00"
#property strict

#include <Trade\Trade.mqh>
#include <Trade\AccountInfo.mqh>
#include <Arrays\ArrayObj.mqh>

//--- Входные параметры
input group "=== ОСНОВНЫЕ НАСТРОЙКИ ==="
input double   InitialLot = 0.01;           // Начальный лот
input double   MaxLot = 0.5;                // Максимальный лот
input int      MagicNumber = 777888;        // Магический номер
input string   TradeComment = "BrainRL";    // Комментарий к сделкам

input group "=== ПАРАМЕТРЫ ОБУЧЕНИЯ ==="
input int      WindowSize = 240;            // Размер окна наблюдения
input int      HoldingPeriod = 22;          // Период удержания для оценки
input int      MaxLags = 200;               // Максимальное количество лагов
input double   LearningRate = 0.1;          // Скорость обучения
input double   ExplorationRate = 0.3;       // Уровень исследования
input double   Gamma = 0.9;                 // Коэффициент дисконтирования
input double   MemoryDecay = 0.99;          // Затухание памяти

input group "=== УПРАВЛЕНИЕ РИСКАМИ ==="
input double   MaxRiskPercent = 2.0;        // Максимальный риск на сделку (%)
input int      StopLossPips = 500;          // Стоп-лосс в пунктах
input int      TakeProfitPips = 1000;       // Тейк-профит в пунктах
input double   MaxDrawdownPercent = 10.0;   // Максимальная просадка (%)
input bool     UseAdaptiveLots = true;      // Использовать адаптивные лоты

input group "=== КОЛЛЕКТИВНЫЙ РАЗУМ ==="
input int      BrainsCount = 5;             // Количество мозгов в коллективе
input bool     UseConsensus = true;         // Использовать консенсусное решение
input double   MinConfidence = 0.15;        // Минимальная уверенность для сделки

input group "=== РЕЖИМЫ РАБОТЫ ==="
input bool     EnableLearning = true;       // Включить обучение
input bool     EnableTrading = true;        // Включить торговлю
input int      LearningPeriod = 100;        // Период обучения (баров)
input bool     ShowDetailedLog = true;      // Детальный лог

input group "=== СОХРАНЕНИЕ/ЗАГРУЗКА ==="
input bool     SaveBrains = true;           // Сохранять мозги
input bool     LoadBrains = true;           // Загружать мозги
input int      SaveInterval = 500;          // Интервал сохранения (баров)
input string   BrainFolder = "BrainRL";     // Папка для сохранения

input group "=== СТАЦИОНАРНЫЕ ПРИЗНАКИ ==="
input bool     UseRSI = true;               // Использовать RSI
input bool     UseCCI = true;               // Использовать CCI
input bool     UseStochastic = true;        // Использовать Stochastic
input bool     UseMACD = true;              // Использовать MACD
input bool     UseATR = true;               // Использовать ATR
input bool     UseBollinger = true;         // Использовать Bollinger Bands
input bool     UseMA = true;                // Использовать Moving Averages
input bool     UseFractals = true;          // Использовать фракталы
input bool     UseADX = true;               // Использовать ADX
input bool     UseWPR = true;               // Использовать Williams %R

//--- Глобальные переменные
CTrade Trade;
CAccountInfo Account;

datetime LastBarTime = 0;
double StartingBalance = 0;
int TotalTrades = 0;
int WinTrades = 0;
int BarsSinceLastSave = 0;

//--- Хендлы индикаторов
int h_RSI = INVALID_HANDLE;
int h_CCI = INVALID_HANDLE;
int h_Stochastic = INVALID_HANDLE;
int h_MACD = INVALID_HANDLE;
int h_ATR = INVALID_HANDLE;
int h_Bollinger = INVALID_HANDLE;
int h_MA_Fast = INVALID_HANDLE;
int h_MA_Slow = INVALID_HANDLE;
int h_ADX = INVALID_HANDLE;
int h_WPR = INVALID_HANDLE;

//+------------------------------------------------------------------+
//| Структура состояния рынка                                        |
//+------------------------------------------------------------------+
struct MarketStateBinary
{
   int       binaryCode[32];
   double    volatility;
   double    momentum;
   double    trend;
   double    price;
   datetime  timestamp;
   double    outcome;
   int       activations;
};

//+------------------------------------------------------------------+
//| Класс нейрона памяти                                            |
//+------------------------------------------------------------------+
class CMemoryNeuron : public CObject
{
public:
   MarketStateBinary marketState;
   double    action;
   double    reward;
   double    qValue;
   double    confidence;
   datetime  birthTime;
   int       activations;
   double    successRate;
   double    importance;
   int       generation;
   
   CMemoryNeuron()
   {
      action = 0.5;
      reward = 0;
      qValue = 0;
      confidence = 0.5;
      birthTime = TimeCurrent();
      activations = 0;
      successRate = 0.5;
      importance = 1.0;
      generation = 1;
      ArrayInitialize(marketState.binaryCode, 0);
      marketState.volatility = 0;
      marketState.momentum = 0;
      marketState.trend = 0;
      marketState.price = 0;
      marketState.timestamp = 0;
      marketState.outcome = 0;
      marketState.activations = 0;
   }
   
   void UpdateMetrics(double newReward)
   {
      activations++;
      reward = newReward;
      
      // Обновление Q-значения
      qValue = qValue + LearningRate * (newReward - qValue);
      
      // Обновление процента успешности
      if(newReward > 0)
         successRate = successRate * 0.9 + 0.1;
      else if(newReward < 0)
         successRate = successRate * 0.9;
      
      // Обновление важности
      importance = successRate * MathLog(activations + 1);
      confidence = (successRate + MathAbs(qValue)) / 2.0;
   }
};

//+------------------------------------------------------------------+
//| Структура эпизода                                               |
//+------------------------------------------------------------------+
struct Episode
{
   MarketStateBinary state;
   double action;
   double reward;
   datetime timestamp;
};

//+------------------------------------------------------------------+
//| Класс машинного мозга                                           |
//+------------------------------------------------------------------+
class CMachineBrain : public CObject
{
private:
   CArrayObj     m_neurons;              // Массив нейронов
   Episode       m_episodes[];           // История эпизодов
   int           m_episodesCount;
   int           m_currentGeneration;
   double        m_brainAge;
   double        m_brainComplexity;
   double        m_overallIntelligence;
   double        m_learningRate;
   double        m_explorationRate;
   double        m_gamma;
   double        m_memoryDecay;
   int           m_lastActivatedNeuron;
   MarketStateBinary m_currentMarketState;
   double        m_totalReward;
   int           m_totalTrades;
   int           m_successfulTrades;
   string        m_name;
   
   // Балансировка классов
   int           m_buySignals;
   int           m_sellSignals;
   int           m_buyTrades;
   int           m_sellTrades;
   double        m_buyReward;
   double        m_sellReward;
   
public:
   CMachineBrain(string name, double lr, double eps, double gamma)
   {
      m_name = name;
      m_learningRate = lr;
      m_explorationRate = eps;
      m_gamma = gamma;
      m_memoryDecay = MemoryDecay;
      m_currentGeneration = 1;
      m_totalReward = 0;
      m_totalTrades = 0;
      m_successfulTrades = 0;
      m_lastActivatedNeuron = -1;
      m_episodesCount = 0;
      m_brainComplexity = 0.1;
      m_overallIntelligence = 0;
      
      // Инициализация балансировки
      m_buySignals = 0;
      m_sellSignals = 0;
      m_buyTrades = 0;
      m_sellTrades = 0;
      m_buyReward = 0;
      m_sellReward = 0;
      
      ArrayResize(m_episodes, 0);
      
      if(ShowDetailedLog)
         Print("🧠 Мозг '", name, "' активирован | LR: ", lr, " | Epsilon: ", eps);
   }
   
   ~CMachineBrain()
   {
      m_neurons.Clear();
   }
   
   //--- Кодирование состояния в бинарный формат
   void EncodeToBinary(double &features[], MarketStateBinary &state)
   {
      int size = ArraySize(features);
      state.volatility = CalculateVolatility(features, size);
      state.momentum = CalculateMomentum(features, size);
      state.trend = CalculateTrend(features, size);
      state.price = size > 0 ? features[0] : 0;
      state.timestamp = TimeCurrent();
      
      ArrayInitialize(state.binaryCode, 0);
      int bitIndex = 0;
      
      // Кодирование волатильности (3 бита)
      int volLevel = (int)(MathMax(0, MathMin(1.0, state.volatility)) * 7);
      for(int i = 0; i < 3; i++)
         state.binaryCode[bitIndex++] = (volLevel >> i) & 1;
      
      // Кодирование моментума (3 бита)
      int momLevel = (int)((state.momentum + 1.0) / 2.0 * 7);
      momLevel = MathMax(0, MathMin(7, momLevel));
      for(int i = 0; i < 3; i++)
         state.binaryCode[bitIndex++] = (momLevel >> i) & 1;
      
      // Кодирование тренда (3 бита)
      int trendLevel = (int)((state.trend + 1.0) / 2.0 * 7);
      trendLevel = MathMax(0, MathMin(7, trendLevel));
      for(int i = 0; i < 3; i++)
         state.binaryCode[bitIndex++] = (trendLevel >> i) & 1;
   }
   
   //--- Расчет волатильности
   double CalculateVolatility(double &features[], int size)
   {
      if(size < 2) return 0.5;
      
      double sum = 0;
      int count = MathMin(size - 1, 10);
      
      for(int i = 0; i < count; i++)
         sum += MathAbs(features[i]);
      
      return MathMin(1.0, sum / count);
   }
   
   //--- Расчет моментума
   double CalculateMomentum(double &features[], int size)
   {
      if(size < 5) return 0.0;
      
      double momentum = 0;
      int count = MathMin(5, size);
      
      for(int i = 0; i < count; i++)
         momentum += features[i];
      
      return MathMax(-1.0, MathMin(1.0, momentum));
   }
   
   //--- Расчет тренда
   double CalculateTrend(double &features[], int size)
   {
      if(size < 3) return 0.0;
      
      double trend = 0;
      int count = MathMin(10, size);
      
      for(int i = 0; i < count; i++)
         trend += features[i] * (count - i) / count;
      
      return MathMax(-1.0, MathMin(1.0, trend));
   }
   
   //--- Поиск похожего состояния
   int FindSimilarState(MarketStateBinary &state)
   {
      int bestMatch = -1;
      double bestSimilarity = 0;
      
      for(int i = 0; i < m_neurons.Total(); i++)
      {
         CMemoryNeuron *neuron = m_neurons.At(i);
         if(neuron == NULL) continue;
         
         double similarity = CalculateSimilarity(state, neuron.marketState);
         
         if(similarity > bestSimilarity)
         {
            bestSimilarity = similarity;
            bestMatch = i;
         }
      }
      
      return bestSimilarity > 0.75 ? bestMatch : -1;
   }
   
   //--- Расчет схожести состояний
   double CalculateSimilarity(MarketStateBinary &state1, MarketStateBinary &state2)
   {
      int matches = 0;
      for(int i = 0; i < 32; i++)
         if(state1.binaryCode[i] == state2.binaryCode[i]) 
            matches++;
      
      return (double)matches / 32.0;
   }
   
   //--- Основная функция мышления
   double Think(double &features[])
   {
      EncodeToBinary(features, m_currentMarketState);
      
      int similarNeuron = FindSimilarState(m_currentMarketState);
      double action = 0.5;
      double randomValue = (double)(MathRand() % 10001) / 10000.0;
      
      // Фаза начального исследования
      if(m_totalTrades < 150)
      {
         int cycle = m_totalTrades % 6;
         if(cycle == 0 || cycle == 1)
            action = 0.75 + randomValue * 0.2;  // BUY
         else if(cycle == 2 || cycle == 3)
            action = 0.1 + randomValue * 0.2;   // SELL
         else
            action = 0.4 + randomValue * 0.2;   // HOLD
         
         m_lastActivatedNeuron = -1;
         
         if(m_totalTrades % 10 == 0 && ShowDetailedLog)
            Print("🎲 [", m_name, "] Exploration: Сделка ", m_totalTrades, 
                  " | Action: ", DoubleToString(action, 3));
      }
      else if(similarNeuron >= 0)
      {
         CMemoryNeuron *neuron = m_neurons.At(similarNeuron);
         
         if(randomValue > m_explorationRate)
         {
            // Эксплуатация
            action = neuron.action;
            
            if(neuron.successRate > 0.6)
               action = MathMin(1.0, action * 1.1);
            else if(neuron.successRate < 0.4)
               action = MathMax(0.0, action * 0.9);
            
            if(m_totalTrades % 20 == 0 && ShowDetailedLog)
               Print("🧠 [", m_name, "] Exploit: Action=", DoubleToString(action, 3), 
                     " | SR=", DoubleToString(neuron.successRate, 2));
         }
         else
         {
            // Исследование
            action = randomValue;
            
            if(m_totalTrades % 20 == 0 && ShowDetailedLog)
               Print("🎲 [", m_name, "] Explore: Random=", DoubleToString(action, 3));
         }
         
         m_lastActivatedNeuron = similarNeuron;
         neuron.activations++;
      }
      else
      {
         // Новое состояние
         action = randomValue;
         m_lastActivatedNeuron = -1;
         
         if(m_totalTrades % 20 == 0 && ShowDetailedLog)
            Print("🆕 [", m_name, "] New state: Random=", DoubleToString(action, 3));
      }
      
      m_overallIntelligence = GetSuccessRate() * m_brainComplexity * 0.1;
      
      // ===== БАЛАНСИРОВКА КЛАССОВ =====
      // Подсчет текущего дисбаланса
      int totalSignals = m_buySignals + m_sellSignals;
      double buyRatio = totalSignals > 0 ? (double)m_buySignals / totalSignals : 0.5;
      double sellRatio = totalSignals > 0 ? (double)m_sellSignals / totalSignals : 0.5;
      
      // Коррекция action если есть сильный дисбаланс (>70% в одну сторону)
      if(totalSignals > 50) // Начинаем балансировку после 50 сигналов
      {
         if(buyRatio > 0.70 && action > 0.6) // Слишком много BUY
         {
            // Снижаем вероятность BUY, смещаем к нейтральной зоне или SELL
            action = action * 0.7 - 0.15;
            action = MathMax(0.0, action);
            
            if(ShowDetailedLog && m_totalTrades % 50 == 0)
               Print("⚖️ [", m_name, "] Баланс: BUY ratio=", DoubleToString(buyRatio, 2), 
                     " → Коррекция на SELL");
         }
         else if(sellRatio > 0.70 && action < 0.4) // Слишком много SELL
         {
            // Снижаем вероятность SELL, смещаем к нейтральной зоне или BUY
            action = action * 0.7 + 0.35;
            action = MathMin(1.0, action);
            
            if(ShowDetailedLog && m_totalTrades % 50 == 0)
               Print("⚖️ [", m_name, "] Баланс: SELL ratio=", DoubleToString(sellRatio, 2), 
                     " → Коррекция на BUY");
         }
      }
      
      // Учитываем успешность каждого класса
      if(m_buyTrades > 10 && m_sellTrades > 10)
      {
         double buyWinRate = m_buyTrades > 0 ? m_buyReward / m_buyTrades : 0;
         double sellWinRate = m_sellTrades > 0 ? m_sellReward / m_sellTrades : 0;
         
         // Если один класс явно лучше, даем ему преимущество
         if(buyWinRate > sellWinRate + 0.3 && action > 0.4 && action < 0.6)
         {
            action = action * 1.2; // Усиливаем BUY в нейтральной зоне
            action = MathMin(1.0, action);
         }
         else if(sellWinRate > buyWinRate + 0.3 && action > 0.4 && action < 0.6)
         {
            action = action * 0.8; // Усиливаем SELL в нейтральной зоне
            action = MathMax(0.0, action);
         }
      }
      
      // Отслеживаем сигналы для статистики
      if(action > 0.6)
         m_buySignals++;
      else if(action < 0.4)
         m_sellSignals++;
      
      return action;
   }
   
   //--- Запоминание действия
   void Remember(double action)
   {
      CMemoryNeuron *newNeuron = new CMemoryNeuron();
      newNeuron.marketState = m_currentMarketState;
      newNeuron.action = action;
      newNeuron.generation = m_currentGeneration;
      
      m_neurons.Add(newNeuron);
      
      m_lastActivatedNeuron = m_neurons.Total() - 1;
      m_brainComplexity = MathLog(m_neurons.Total() + 1);
   }
   
   //--- Обучение на основе вознаграждения
   void Learn(double reward)
   {
      if(m_lastActivatedNeuron >= 0 && m_lastActivatedNeuron < m_neurons.Total())
      {
         CMemoryNeuron *neuron = m_neurons.At(m_lastActivatedNeuron);
         neuron.UpdateMetrics(reward);
         
         // Отслеживание по классам
         if(neuron.action > 0.6) // BUY
         {
            m_buyTrades++;
            m_buyReward += reward;
         }
         else if(neuron.action < 0.4) // SELL
         {
            m_sellTrades++;
            m_sellReward += reward;
         }
         
         if(reward > 0)
            m_successfulTrades++;
         
         m_totalReward += reward;
         m_totalTrades++;
      }
      
      // Периодическая очистка и эволюция
      if(m_totalTrades % 100 == 0 && m_totalTrades > 0)
      {
         Prune();
         Evolve();
      }
   }
   
   //--- Прунинг (удаление плохих нейронов)
   void Prune()
   {
      if(m_neurons.Total() < 1000) return;
      
      int removed = 0;
      
      for(int i = m_neurons.Total() - 1; i >= 0 && removed < 100; i--)
      {
         CMemoryNeuron *neuron = m_neurons.At(i);
         if(neuron == NULL) continue;
         
         if(neuron.activations > 10 && neuron.successRate < 0.35)
         {
            m_neurons.Delete(i);
            removed++;
         }
      }
      
      if(removed > 0 && ShowDetailedLog)
         Print("🧹 [", m_name, "] Прунинг: удалено ", removed, " нейронов");
   }
   
   //--- Эволюция (переход к новому поколению)
   void Evolve()
   {
      m_currentGeneration++;
      m_explorationRate *= m_memoryDecay;
      m_explorationRate = MathMax(0.01, m_explorationRate);
      
      if(ShowDetailedLog)
         Print("🧬 [", m_name, "] Поколение ", m_currentGeneration, 
               " | Exploration: ", DoubleToString(m_explorationRate, 3));
   }
   
   //--- Получение метрик
   int GetNeuronsCount() { return m_neurons.Total(); }
   double GetSuccessRate() { return m_totalTrades > 0 ? (double)m_successfulTrades / m_totalTrades : 0; }
   double GetIntelligence() { return m_overallIntelligence; }
   double GetTotalReward() { return m_totalReward; }
   int GetTotalTrades() { return m_totalTrades; }
   string GetName() { return m_name; }
   
   //--- Статистика
   void PrintStats()
   {
      double buyWinRate = m_buyTrades > 0 ? m_buyReward / m_buyTrades : 0;
      double sellWinRate = m_sellTrades > 0 ? m_sellReward / m_sellTrades : 0;
      int totalSignals = m_buySignals + m_sellSignals;
      double buyRatio = totalSignals > 0 ? (double)m_buySignals / totalSignals * 100 : 0;
      double sellRatio = totalSignals > 0 ? (double)m_sellSignals / totalSignals * 100 : 0;
      
      Print("╔══════════════════════════════════════════╗");
      Print("║  🧠 СТАТИСТИКА МОЗГА: ", m_name);
      Print("╠══════════════════════════════════════════╣");
      Print("║  Нейронов: ", m_neurons.Total());
      Print("║  Поколение: ", m_currentGeneration);
      Print("║  Сделок: ", m_totalTrades);
      Print("║  Win Rate: ", DoubleToString(GetSuccessRate() * 100, 1), "%");
      Print("║  Прибыль: ", DoubleToString(m_totalReward, 2));
      Print("║  Интеллект: ", DoubleToString(m_overallIntelligence, 4));
      Print("╠══════════════════════════════════════════╣");
      Print("║  ⚖️ БАЛАНС КЛАССОВ:");
      Print("║  BUY сигналы: ", m_buySignals, " (", DoubleToString(buyRatio, 1), "%)");
      Print("║  SELL сигналы: ", m_sellSignals, " (", DoubleToString(sellRatio, 1), "%)");
      Print("║  BUY сделки: ", m_buyTrades, " | Avg: ", DoubleToString(buyWinRate, 3));
      Print("║  SELL сделки: ", m_sellTrades, " | Avg: ", DoubleToString(sellWinRate, 3));
      Print("╚══════════════════════════════════════════╝");
   }
   
   //--- Сохранение мозга в файл
   bool SaveToFile(string folderName)
   {
      string filename = folderName + "\\" + m_name + ".brain";
      int handle = FileOpen(filename, FILE_WRITE | FILE_BIN | FILE_COMMON);
      
      if(handle == INVALID_HANDLE)
      {
         Print("❌ Ошибка создания файла: ", filename, " Error: ", GetLastError());
         return false;
      }
      
      // Сохранение метаданных
      FileWriteInteger(handle, m_neurons.Total());
      FileWriteInteger(handle, m_currentGeneration);
      FileWriteDouble(handle, m_totalReward);
      FileWriteInteger(handle, m_totalTrades);
      FileWriteInteger(handle, m_successfulTrades);
      FileWriteDouble(handle, m_learningRate);
      FileWriteDouble(handle, m_explorationRate);
      FileWriteDouble(handle, m_gamma);
      
      // Сохранение статистики баланса классов
      FileWriteInteger(handle, m_buySignals);
      FileWriteInteger(handle, m_sellSignals);
      FileWriteInteger(handle, m_buyTrades);
      FileWriteInteger(handle, m_sellTrades);
      FileWriteDouble(handle, m_buyReward);
      FileWriteDouble(handle, m_sellReward);
      
      // Сохранение нейронов (максимум 5000000)
      int toSave = MathMin(m_neurons.Total(), 5000000);
      FileWriteInteger(handle, toSave);
      
      for(int i = 0; i < toSave; i++)
      {
         CMemoryNeuron *neuron = m_neurons.At(i);
         if(neuron == NULL) continue;
         
         // Сохранение бинарного кода
         for(int j = 0; j < 32; j++)
            FileWriteInteger(handle, neuron.marketState.binaryCode[j]);
         
         // Сохранение характеристик состояния
         FileWriteDouble(handle, neuron.marketState.volatility);
         FileWriteDouble(handle, neuron.marketState.momentum);
         FileWriteDouble(handle, neuron.marketState.trend);
         FileWriteDouble(handle, neuron.marketState.price);
         
         // Сохранение параметров нейрона
         FileWriteDouble(handle, neuron.action);
         FileWriteDouble(handle, neuron.reward);
         FileWriteDouble(handle, neuron.qValue);
         FileWriteDouble(handle, neuron.confidence);
         FileWriteInteger(handle, neuron.activations);
         FileWriteDouble(handle, neuron.successRate);
         FileWriteDouble(handle, neuron.importance);
         FileWriteInteger(handle, neuron.generation);
      }
      
      FileClose(handle);
      
      Print("💾 Мозг '", m_name, "' сохранен: ", toSave, " нейронов в ", filename);
      return true;
   }
   
   //--- Загрузка мозга из файла
   bool LoadFromFile(string folderName)
   {
      string filename = folderName + "\\" + m_name + ".brain";
      int handle = FileOpen(filename, FILE_READ | FILE_BIN | FILE_COMMON);
      
      if(handle == INVALID_HANDLE)
      {
         Print("⚠️ Файл не найден: ", filename, " - создается новый мозг");
         return false;
      }
      
      // Очистка существующих нейронов
      m_neurons.Clear();
      
      // Загрузка метаданных
      int neuronsCount = FileReadInteger(handle);
      m_currentGeneration = FileReadInteger(handle);
      m_totalReward = FileReadDouble(handle);
      m_totalTrades = FileReadInteger(handle);
      m_successfulTrades = FileReadInteger(handle);
      m_learningRate = FileReadDouble(handle);
      m_explorationRate = FileReadDouble(handle);
      m_gamma = FileReadDouble(handle);
      
      // Загрузка статистики баланса классов
      m_buySignals = FileReadInteger(handle);
      m_sellSignals = FileReadInteger(handle);
      m_buyTrades = FileReadInteger(handle);
      m_sellTrades = FileReadInteger(handle);
      m_buyReward = FileReadDouble(handle);
      m_sellReward = FileReadDouble(handle);
      
      // Загрузка количества сохраненных нейронов
      int savedNeurons = FileReadInteger(handle);
      
      // Загрузка нейронов
      for(int i = 0; i < savedNeurons; i++)
      {
         CMemoryNeuron *neuron = new CMemoryNeuron();
         
         // Загрузка бинарного кода
         for(int j = 0; j < 32; j++)
            neuron.marketState.binaryCode[j] = FileReadInteger(handle);
         
         // Загрузка характеристик состояния
         neuron.marketState.volatility = FileReadDouble(handle);
         neuron.marketState.momentum = FileReadDouble(handle);
         neuron.marketState.trend = FileReadDouble(handle);
         neuron.marketState.price = FileReadDouble(handle);
         
         // Загрузка параметров нейрона
         neuron.action = FileReadDouble(handle);
         neuron.reward = FileReadDouble(handle);
         neuron.qValue = FileReadDouble(handle);
         neuron.confidence = FileReadDouble(handle);
         neuron.activations = FileReadInteger(handle);
         neuron.successRate = FileReadDouble(handle);
         neuron.importance = FileReadDouble(handle);
         neuron.generation = FileReadInteger(handle);
         
         m_neurons.Add(neuron);
      }
      
      FileClose(handle);
      
      m_brainComplexity = MathLog(m_neurons.Total() + 1);
      m_overallIntelligence = GetSuccessRate() * m_brainComplexity * 0.1;
      
      int totalSignals = m_buySignals + m_sellSignals;
      double buyRatio = totalSignals > 0 ? (double)m_buySignals / totalSignals * 100 : 50;
      double sellRatio = totalSignals > 0 ? (double)m_sellSignals / totalSignals * 100 : 50;
      
      Print("✅ Мозг '", m_name, "' загружен: ", m_neurons.Total(), " нейронов | ",
            "Поколение: ", m_currentGeneration, " | Win Rate: ", 
            DoubleToString(GetSuccessRate() * 100, 1), "% | ",
            "BUY/SELL: ", DoubleToString(buyRatio, 0), "%/", DoubleToString(sellRatio, 0), "%");
      
      return true;
   }
};

//+------------------------------------------------------------------+
//| Класс коллективного разума                                      |
//+------------------------------------------------------------------+
class CCollectiveMind : public CObject
{
private:
   CArrayObj     m_brains;
   string        m_groupName;
   
public:
   CCollectiveMind(string name, int brainsCount, double lr, double eps, double gamma)
   {
      m_groupName = name;
      
      for(int i = 0; i < brainsCount; i++)
      {
         string brainName = name + "_Brain" + IntegerToString(i);
         double brainLR = lr * (0.8 + (MathRand() % 1000) / 10000.0 * 0.4);
         double brainEps = eps * (0.8 + (MathRand() % 1000) / 10000.0 * 0.4);
         
         CMachineBrain *brain = new CMachineBrain(brainName, brainLR, brainEps, gamma);
         m_brains.Add(brain);
      }
      
      Print("🌐 Коллективный разум '", name, "' создан | Мозгов: ", brainsCount);
   }
   
   ~CCollectiveMind()
   {
      m_brains.Clear();
   }
   
   //--- Консенсусное мышление
   double ConsensusThink(double &state[])
   {
      double totalAction = 0;
      double totalWeight = 0;
      
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain == NULL) continue;
         
         double action = brain.Think(state);
         double weight = brain.GetSuccessRate() + 0.1;
         
         totalAction += action * weight;
         totalWeight += weight;
      }
      
      return totalWeight > 0 ? totalAction / totalWeight : 0.5;
   }
   
   //--- Коллективное запоминание
   void CollectiveRemember(double action)
   {
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain != NULL)
            brain.Remember(action);
      }
   }
   
   //--- Коллективное обучение
   void CollectiveLearn(double reward)
   {
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain != NULL)
            brain.Learn(reward);
      }
   }
   
   //--- Получение метрик
   int GetTotalNeurons()
   {
      int total = 0;
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain != NULL)
            total += brain.GetNeuronsCount();
      }
      return total;
   }
   
   double GetCollectiveIntelligence()
   {
      double total = 0;
      int count = 0;
      
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain == NULL) continue;
         
         total += brain.GetIntelligence();
         count++;
      }
      
      return count > 0 ? total / count : 0;
   }
   
   //--- Статистика
   void PrintCollectiveStats()
   {
      Print("╔════════════════════════════════════════════╗");
      Print("║  🌐 КОЛЛЕКТИВНЫЙ РАЗУМ: ", m_groupName);
      Print("╠════════════════════════════════════════════╣");
      Print("║  Мозгов: ", m_brains.Total());
      Print("║  Нейронов: ", GetTotalNeurons());
      Print("║  Интеллект: ", DoubleToString(GetCollectiveIntelligence(), 4));
      
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain == NULL) continue;
         
         Print("║  Мозг ", i, ": ", brain.GetNeuronsCount(), " нейронов | ",
               "IQ: ", DoubleToString(brain.GetIntelligence(), 3), " | ",
               "Win: ", DoubleToString(brain.GetSuccessRate() * 100, 1), "%");
      }
      
      Print("╚════════════════════════════════════════════╝");
   }
   
   //--- Сохранение всех мозгов
   bool SaveAllBrains(string folderName)
   {
      bool allSuccess = true;
      
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain == NULL) continue;
         
         if(!brain.SaveToFile(folderName))
            allSuccess = false;
      }
      
      if(allSuccess)
         Print("💾 Коллектив '", m_groupName, "' полностью сохранен");
      
      return allSuccess;
   }
   
   //--- Загрузка всех мозгов
   bool LoadAllBrains(string folderName)
   {
      bool anyLoaded = false;
      
      for(int i = 0; i < m_brains.Total(); i++)
      {
         CMachineBrain *brain = m_brains.At(i);
         if(brain == NULL) continue;
         
         if(brain.LoadFromFile(folderName))
            anyLoaded = true;
      }
      
      if(anyLoaded)
         Print("✅ Коллектив '", m_groupName, "' загружен");
      else
         Print("🆕 Коллектив '", m_groupName, "' создан с нуля");
      
      return anyLoaded;
   }
};

//--- Глобальный коллективный разум
CCollectiveMind *g_collectiveMind = NULL;

//+------------------------------------------------------------------+
//| Создание расширенных стационарных признаков                     |
//+------------------------------------------------------------------+
void CreateFeatures(double &features[])
{
   MqlRates rates[];
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, WindowSize + MaxLags + 1, rates);
   
   if(copied <= 0)
   {
      ArrayResize(features, 0);
      return;
   }
   
   int featureIndex = 0;
   int totalFeatures = 0;
   
   // Подсчет количества признаков
   totalFeatures += WindowSize; // Базовые ценовые изменения
   if(UseRSI) totalFeatures += 3;
   if(UseCCI) totalFeatures += 1;
   if(UseStochastic) totalFeatures += 2;
   if(UseMACD) totalFeatures += 3;
   if(UseATR) totalFeatures += 1;
   if(UseBollinger) totalFeatures += 3;
   if(UseMA) totalFeatures += 4;
   if(UseFractals) totalFeatures += 2;
   if(UseADX) totalFeatures += 3;
   if(UseWPR) totalFeatures += 1;
   
   ArrayResize(features, totalFeatures);
   ArrayInitialize(features, 0);
   
   // 1. БАЗОВЫЕ ЦЕНОВЫЕ ИЗМЕНЕНИЯ (нормализованные)
   for(int i = 0; i < WindowSize && i < copied - 1; i++)
   {
      if(rates[copied - 1 - i - 1].close > 0)
         features[featureIndex++] = (rates[copied - 1 - i].close - rates[copied - 1 - i - 1].close) / 
                                   rates[copied - 1 - i - 1].close;
      else
         features[featureIndex++] = 0;
   }
   
   // 2. RSI (Relative Strength Index) - стационарный осциллятор
   if(UseRSI && h_RSI != INVALID_HANDLE)
   {
      double rsi[];
      if(CopyBuffer(h_RSI, 0, 0, 3, rsi) > 0)
      {
         features[featureIndex++] = (rsi[0] - 50) / 50;  // Нормализация [-1, 1]
         
         // Скорость изменения RSI
         if(ArraySize(rsi) >= 2)
            features[featureIndex++] = (rsi[0] - rsi[1]) / 50;
         else
            features[featureIndex++] = 0;
         
         // Зона перекупленности/перепроданности
         if(rsi[0] > 70)
            features[featureIndex++] = 1;
         else if(rsi[0] < 30)
            features[featureIndex++] = -1;
         else
            features[featureIndex++] = 0;
      }
      else
         featureIndex += 3;
   }
   
   // 3. CCI (Commodity Channel Index) - стационарный
   if(UseCCI && h_CCI != INVALID_HANDLE)
   {
      double cci[];
      if(CopyBuffer(h_CCI, 0, 0, 1, cci) > 0)
      {
         features[featureIndex++] = MathMax(-1, MathMin(1, cci[0] / 200));  // Нормализация
      }
      else
         featureIndex++;
   }
   
   // 4. STOCHASTIC - стационарный осциллятор
   if(UseStochastic && h_Stochastic != INVALID_HANDLE)
   {
      double main[], signal[];
      if(CopyBuffer(h_Stochastic, 0, 0, 1, main) > 0 && 
         CopyBuffer(h_Stochastic, 1, 0, 1, signal) > 0)
      {
         features[featureIndex++] = (main[0] - 50) / 50;     // Main line
         features[featureIndex++] = (signal[0] - 50) / 50;   // Signal line
      }
      else
         featureIndex += 2;
   }
   
   // 5. MACD - почти стационарный (разница двух MA)
   if(UseMACD && h_MACD != INVALID_HANDLE)
   {
      double main[], signal[];
      if(CopyBuffer(h_MACD, 0, 0, 2, main) > 0 && 
         CopyBuffer(h_MACD, 1, 0, 2, signal) > 0)
      {
         double avgPrice = (rates[copied-1].high + rates[copied-1].low) / 2;
         if(avgPrice > 0)
         {
            features[featureIndex++] = main[0] / avgPrice;      // MACD нормализованный
            features[featureIndex++] = signal[0] / avgPrice;    // Signal нормализованный
            features[featureIndex++] = (main[0] - signal[0]) / avgPrice;  // Histogram
         }
         else
            featureIndex += 3;
      }
      else
         featureIndex += 3;
   }
   
   // 6. ATR (Average True Range) - относительная волатильность
   if(UseATR && h_ATR != INVALID_HANDLE)
   {
      double atr[];
      if(CopyBuffer(h_ATR, 0, 0, 1, atr) > 0)
      {
         if(rates[copied-1].close > 0)
            features[featureIndex++] = atr[0] / rates[copied-1].close;  // Относительная волатильность
         else
            features[featureIndex++] = 0;
      }
      else
         featureIndex++;
   }
   
   // 7. BOLLINGER BANDS - стационарные отклонения
   if(UseBollinger && h_Bollinger != INVALID_HANDLE)
   {
      double upper[], middle[], lower[];
      if(CopyBuffer(h_Bollinger, 0, 0, 1, upper) > 0 &&
         CopyBuffer(h_Bollinger, 1, 0, 1, middle) > 0 &&
         CopyBuffer(h_Bollinger, 2, 0, 1, lower) > 0)
      {
         double currentPrice = rates[copied-1].close;
         double bandwidth = upper[0] - lower[0];
         
         if(bandwidth > 0)
         {
            // Положение цены относительно полос
            features[featureIndex++] = (currentPrice - middle[0]) / bandwidth;
            
            // Ширина канала (волатильность)
            features[featureIndex++] = bandwidth / middle[0];
            
            // %B индикатор
            features[featureIndex++] = (currentPrice - lower[0]) / bandwidth;
         }
         else
            featureIndex += 3;
      }
      else
         featureIndex += 3;
   }
   
   // 8. MOVING AVERAGES - отношения для стационарности
   if(UseMA && h_MA_Fast != INVALID_HANDLE && h_MA_Slow != INVALID_HANDLE)
   {
      double ma_fast[], ma_slow[];
      if(CopyBuffer(h_MA_Fast, 0, 0, 2, ma_fast) > 0 &&
         CopyBuffer(h_MA_Slow, 0, 0, 2, ma_slow) > 0)
      {
         double currentPrice = rates[copied-1].close;
         
         if(ma_fast[0] > 0 && ma_slow[0] > 0)
         {
            // Отклонение цены от быстрой MA
            features[featureIndex++] = (currentPrice - ma_fast[0]) / ma_fast[0];
            
            // Отклонение цены от медленной MA
            features[featureIndex++] = (currentPrice - ma_slow[0]) / ma_slow[0];
            
            // Отношение быстрой к медленной (тренд)
            features[featureIndex++] = (ma_fast[0] - ma_slow[0]) / ma_slow[0];
            
            // Скорость быстрой MA
            if(ArraySize(ma_fast) >= 2 && ma_fast[1] > 0)
               features[featureIndex++] = (ma_fast[0] - ma_fast[1]) / ma_fast[1];
            else
               features[featureIndex++] = 0;
         }
         else
            featureIndex += 4;
      }
      else
         featureIndex += 4;
   }
   
   // 9. FRACTALS - паттерны разворота
   if(UseFractals)
   {
      // Проверка фрактала вверх
      bool upFractal = false;
      if(copied >= 5)
      {
         int idx = copied - 3;
         if(rates[idx].high > rates[idx-2].high && 
            rates[idx].high > rates[idx-1].high &&
            rates[idx].high > rates[idx+1].high && 
            rates[idx].high > rates[idx+2].high)
            upFractal = true;
      }
      features[featureIndex++] = upFractal ? 1 : 0;
      
      // Проверка фрактала вниз
      bool downFractal = false;
      if(copied >= 5)
      {
         int idx = copied - 3;
         if(rates[idx].low < rates[idx-2].low && 
            rates[idx].low < rates[idx-1].low &&
            rates[idx].low < rates[idx+1].low && 
            rates[idx].low < rates[idx+2].low)
            downFractal = true;
      }
      features[featureIndex++] = downFractal ? 1 : 0;
   }
   
   // 10. ADX (Average Directional Index) - сила тренда
   if(UseADX && h_ADX != INVALID_HANDLE)
   {
      double adx[], plus_di[], minus_di[];
      if(CopyBuffer(h_ADX, 0, 0, 1, adx) > 0 &&
         CopyBuffer(h_ADX, 1, 0, 1, plus_di) > 0 &&
         CopyBuffer(h_ADX, 2, 0, 1, minus_di) > 0)
      {
         features[featureIndex++] = adx[0] / 100;  // Сила тренда [0, 1]
         features[featureIndex++] = (plus_di[0] - 20) / 80;  // +DI нормализованный
         features[featureIndex++] = (minus_di[0] - 20) / 80; // -DI нормализованный
      }
      else
         featureIndex += 3;
   }
   
   // 11. WILLIAMS %R - стационарный осциллятор
   if(UseWPR && h_WPR != INVALID_HANDLE)
   {
      double wpr[];
      if(CopyBuffer(h_WPR, 0, 0, 1, wpr) > 0)
      {
         features[featureIndex++] = (wpr[0] + 50) / 50;  // Нормализация [-1, 1]
      }
      else
         featureIndex++;
   }
   
   // Проверка на NaN и Inf
   for(int i = 0; i < ArraySize(features); i++)
   {
      if(!MathIsValidNumber(features[i]))
         features[i] = 0;
   }
}

//+------------------------------------------------------------------+
//| Расчет адаптивного размера лота                                 |
//+------------------------------------------------------------------+
double CalculateAdaptiveLot(double confidence)
{
   if(!UseAdaptiveLots)
      return InitialLot;
   
   double balance = Account.Balance();
   double riskAmount = balance * MaxRiskPercent / 100.0;
   
   // Адаптация на основе уверенности
   double adjustedRisk = riskAmount * MathAbs(confidence - 0.5) * 2.0;
   
   // Расчет лота на основе стоп-лосса
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double stopLossValue = StopLossPips * tickValue / tickSize;
   
   double lotSize = adjustedRisk / stopLossValue;
   
   // Нормализация
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   
   lotSize = MathMax(minLot, MathMin(maxLot, 
                     MathFloor(lotSize / lotStep) * lotStep));
   
   lotSize = MathMin(lotSize, MaxLot);
   lotSize = MathMax(lotSize, InitialLot);
   
   return NormalizeDouble(lotSize, 2);
}

//+------------------------------------------------------------------+
//| Проверка максимальной просадки                                  |
//+------------------------------------------------------------------+
bool CheckDrawdown()
{
   double equity = Account.Equity();
   double balance = Account.Balance();
   
   if(balance <= 0) return false;
   
   double drawdownPercent = (balance - equity) / balance * 100.0;
   
   if(drawdownPercent > MaxDrawdownPercent)
   {
      Print("⚠️ Достигнут максимальный уровень просадки: ", 
            DoubleToString(drawdownPercent, 2), "%");
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Проверка нового бара                                            |
//+------------------------------------------------------------------+
bool IsNewBar()
{
   datetime currentTime = iTime(_Symbol, PERIOD_CURRENT, 0);
   
   if(currentTime != LastBarTime)
   {
      LastBarTime = currentTime;
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Подсчет открытых позиций                                        |
//+------------------------------------------------------------------+
int CountOpenPositions()
{
   int count = 0;
   
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
            PositionGetInteger(POSITION_MAGIC) == MagicNumber)
            count++;
      }
   }
   
   return count;
}

//+------------------------------------------------------------------+
//| Открытие позиции на основе сигнала                              |
//+------------------------------------------------------------------+
void OpenPosition(double action, double confidence)
{
   if(!EnableTrading) return;
   if(!CheckDrawdown()) return;
   if(CountOpenPositions() > 0) return;
   
   double lotSize = CalculateAdaptiveLot(confidence);
   
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   Trade.SetExpertMagicNumber(MagicNumber);
   
   bool result = false;
   
   if(action > 0.6) // BUY
   {
      double sl = ask - StopLossPips * point;
      double tp = ask + TakeProfitPips * point;
      
      result = Trade.Buy(lotSize, _Symbol, ask, sl, tp, TradeComment);
      
      if(result)
      {
         TotalTrades++;
         Print("✅ BUY открыт | Лот: ", lotSize, " | Уверенность: ", 
               DoubleToString(confidence * 100, 2), "%");
      }
   }
   else if(action < 0.4) // SELL
   {
      double sl = bid + StopLossPips * point;
      double tp = bid - TakeProfitPips * point;
      
      result = Trade.Sell(lotSize, _Symbol, bid, sl, tp, TradeComment);
      
      if(result)
      {
         TotalTrades++;
         Print("✅ SELL открыт | Лот: ", lotSize, " | Уверенность: ", 
               DoubleToString(confidence * 100, 2), "%");
      }
   }
}

//+------------------------------------------------------------------+
//| Обновление статистики по закрытым позициям                      |
//+------------------------------------------------------------------+
void UpdateStatistics()
{
   for(int i = HistoryDealsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = HistoryDealGetTicket(i);
      
      if(HistoryDealGetInteger(ticket, DEAL_MAGIC) != MagicNumber)
         continue;
      
      if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol)
         continue;
      
      double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
      
      if(profit > 0)
         WinTrades++;
   }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   Trade.SetExpertMagicNumber(MagicNumber);
   Trade.SetDeviationInPoints(10);
   Trade.SetTypeFilling(ORDER_FILLING_FOK);
   
   StartingBalance = Account.Balance();
   LastBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
   BarsSinceLastSave = 0;
   
   // Инициализация индикаторов
   Print("🔧 Инициализация индикаторов...");
   
   if(UseRSI)
      h_RSI = iRSI(_Symbol, PERIOD_CURRENT, 14, PRICE_CLOSE);
   
   if(UseCCI)
      h_CCI = iCCI(_Symbol, PERIOD_CURRENT, 14, PRICE_TYPICAL);
   
   if(UseStochastic)
      h_Stochastic = iStochastic(_Symbol, PERIOD_CURRENT, 5, 3, 3, MODE_SMA, STO_LOWHIGH);
   
   if(UseMACD)
      h_MACD = iMACD(_Symbol, PERIOD_CURRENT, 12, 26, 9, PRICE_CLOSE);
   
   if(UseATR)
      h_ATR = iATR(_Symbol, PERIOD_CURRENT, 14);
   
   if(UseBollinger)
      h_Bollinger = iBands(_Symbol, PERIOD_CURRENT, 20, 0, 2, PRICE_CLOSE);
   
   if(UseMA)
   {
      h_MA_Fast = iMA(_Symbol, PERIOD_CURRENT, 20, 0, MODE_EMA, PRICE_CLOSE);
      h_MA_Slow = iMA(_Symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE);
   }
   
   if(UseADX)
      h_ADX = iADX(_Symbol, PERIOD_CURRENT, 14);
   
   if(UseWPR)
      h_WPR = iWPR(_Symbol, PERIOD_CURRENT, 14);
   
   // Проверка индикаторов
   int validIndicators = 0;
   int totalIndicators = 0;
   
   if(UseRSI) { totalIndicators++; if(h_RSI != INVALID_HANDLE) validIndicators++; }
   if(UseCCI) { totalIndicators++; if(h_CCI != INVALID_HANDLE) validIndicators++; }
   if(UseStochastic) { totalIndicators++; if(h_Stochastic != INVALID_HANDLE) validIndicators++; }
   if(UseMACD) { totalIndicators++; if(h_MACD != INVALID_HANDLE) validIndicators++; }
   if(UseATR) { totalIndicators++; if(h_ATR != INVALID_HANDLE) validIndicators++; }
   if(UseBollinger) { totalIndicators++; if(h_Bollinger != INVALID_HANDLE) validIndicators++; }
   if(UseMA) { totalIndicators++; if(h_MA_Fast != INVALID_HANDLE && h_MA_Slow != INVALID_HANDLE) validIndicators++; }
   if(UseADX) { totalIndicators++; if(h_ADX != INVALID_HANDLE) validIndicators++; }
   if(UseWPR) { totalIndicators++; if(h_WPR != INVALID_HANDLE) validIndicators++; }
   
   Print("✅ Индикаторов инициализировано: ", validIndicators, "/", totalIndicators);
   
   // Создание коллективного разума
   g_collectiveMind = new CCollectiveMind("MainMind", BrainsCount, 
                                          LearningRate, ExplorationRate, Gamma);
   
   if(g_collectiveMind == NULL)
   {
      Print("❌ Ошибка создания коллективного разума");
      return INIT_FAILED;
   }
   
   // Загрузка мозгов из файлов
   if(LoadBrains)
   {
      Print("📂 Загрузка сохраненных мозгов из папки: ", BrainFolder);
      g_collectiveMind.LoadAllBrains(BrainFolder);
   }
   else
   {
      Print("🆕 Создание новых мозгов (загрузка отключена)");
   }
   
   Print("╔═══════════════════════════════════════════════════╗");
   Print("║     🧠 BRAINRL EXPERT V2.0 ИНИЦИАЛИЗИРОВАН        ║");
   Print("╠═══════════════════════════════════════════════════╣");
   Print("║  Символ: ", _Symbol);
   Print("║  Таймфрейм: ", EnumToString(PERIOD_CURRENT));
   Print("║  Мозгов в коллективе: ", BrainsCount);
   Print("║  Начальный баланс: $", DoubleToString(StartingBalance, 2));
   Print("║  Обучение: ", EnableLearning ? "ВКЛ ✅" : "ВЫКЛ ❌");
   Print("║  Торговля: ", EnableTrading ? "ВКЛ ✅" : "ВЫКЛ ❌");
   Print("║  Сохранение мозгов: ", SaveBrains ? "ВКЛ ✅" : "ВЫКЛ ❌");
   Print("║  Интервал сохранения: ", SaveInterval, " баров");
   Print("║  Активных индикаторов: ", validIndicators);
   Print("╚═══════════════════════════════════════════════════╝");
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Сохранение мозгов перед выходом
   if(SaveBrains && g_collectiveMind != NULL)
   {
      Print("💾 Сохранение мозгов перед завершением...");
      g_collectiveMind.SaveAllBrains(BrainFolder);
   }
   
   if(g_collectiveMind != NULL)
   {
      Print("\n═══════════════════════════════════════════");
      Print("📊 ФИНАЛЬНАЯ СТАТИСТИКА");
      Print("═══════════════════════════════════════════");
      
      g_collectiveMind.PrintCollectiveStats();
      
      double winRate = TotalTrades > 0 ? (double)WinTrades / TotalTrades * 100 : 0;
      double finalBalance = Account.Balance();
      double totalProfit = finalBalance - StartingBalance;
      
      Print("\n📈 ТОРГОВЫЕ РЕЗУЛЬТАТЫ:");
      Print("   Начальный баланс: $", DoubleToString(StartingBalance, 2));
      Print("   Финальный баланс: $", DoubleToString(finalBalance, 2));
      Print("   Общая прибыль: $", DoubleToString(totalProfit, 2));
      Print("   Всего сделок: ", TotalTrades);
      Print("   Прибыльных: ", WinTrades);
      Print("   Win Rate: ", DoubleToString(winRate, 2), "%");
      Print("═══════════════════════════════════════════\n");
      
      delete g_collectiveMind;
      g_collectiveMind = NULL;
   }
   
   // Освобождение хендлов индикаторов
   if(h_RSI != INVALID_HANDLE) IndicatorRelease(h_RSI);
   if(h_CCI != INVALID_HANDLE) IndicatorRelease(h_CCI);
   if(h_Stochastic != INVALID_HANDLE) IndicatorRelease(h_Stochastic);
   if(h_MACD != INVALID_HANDLE) IndicatorRelease(h_MACD);
   if(h_ATR != INVALID_HANDLE) IndicatorRelease(h_ATR);
   if(h_Bollinger != INVALID_HANDLE) IndicatorRelease(h_Bollinger);
   if(h_MA_Fast != INVALID_HANDLE) IndicatorRelease(h_MA_Fast);
   if(h_MA_Slow != INVALID_HANDLE) IndicatorRelease(h_MA_Slow);
   if(h_ADX != INVALID_HANDLE) IndicatorRelease(h_ADX);
   if(h_WPR != INVALID_HANDLE) IndicatorRelease(h_WPR);
   
   Print("🔴 BrainRL Expert остановлен. Причина: ", reason);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   if(!IsNewBar()) return;
   if(g_collectiveMind == NULL) return;
   
   BarsSinceLastSave++;
   
   // Периодическое сохранение мозгов
   if(SaveBrains && BarsSinceLastSave >= SaveInterval)
   {
      Print("💾 Автосохранение мозгов (каждые ", SaveInterval, " баров)...");
      g_collectiveMind.SaveAllBrains(BrainFolder);
      BarsSinceLastSave = 0;
   }
   
   // Создание признаков
   double features[];
   CreateFeatures(features);
   
   if(ArraySize(features) == 0)
   {
      Print("⚠️ Недостаточно данных для анализа");
      return;
   }
   
   // Получение консенсусного решения
   double action = 0.5;
   
   if(UseConsensus)
      action = g_collectiveMind.ConsensusThink(features);
   
   double confidence = MathAbs(action - 0.5) * 2.0;
   
   // Логирование
   if(ShowDetailedLog)
   {
      Print("\n🔮 ", TimeToString(TimeCurrent()), " - СИГНАЛ");
      Print("   Action: ", DoubleToString(action, 4));
      Print("   Confidence: ", DoubleToString(confidence * 100, 2), "%");
      Print("   Direction: ", action > 0.6 ? "🟢 BUY" : (action < 0.4 ? "🔴 SELL" : "⚪ HOLD"));
      Print("   Нейронов: ", g_collectiveMind.GetTotalNeurons());
      Print("   Интеллект: ", DoubleToString(g_collectiveMind.GetCollectiveIntelligence(), 4));
      Print("   Признаков: ", ArraySize(features));
   }
   
   // Открытие позиции при достаточной уверенности
   if(confidence >= MinConfidence)
   {
      OpenPosition(action, confidence);
      
      if(EnableLearning)
      {
         g_collectiveMind.CollectiveRemember(action);
         
         // Оценка награды будет на следующем баре
         // Здесь используем упрощенную оценку
         double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
         static double lastPrice = currentPrice;
         
         double priceChange = (currentPrice - lastPrice) / lastPrice;
         double reward = 0;
         
         if(action > 0.6) // Ожидали рост
            reward = priceChange > 0 ? 1.0 : -1.0;
         else if(action < 0.4) // Ожидали падение
            reward = priceChange < 0 ? 1.0 : -1.0;
         
         g_collectiveMind.CollectiveLearn(reward);
         
         lastPrice = currentPrice;
      }
   }
   
   // Обновление статистики
   UpdateStatistics();
   
   // Периодическая печать статистики
   static int barCounter = 0;
   barCounter++;
   
   if(barCounter >= LearningPeriod)
   {
      barCounter = 0;
      g_collectiveMind.PrintCollectiveStats();
      
      Print("\n📊 ПРОМЕЖУТОЧНЫЕ РЕЗУЛЬТАТЫ:");
      Print("   Баланс: $", DoubleToString(Account.Balance(), 2));
      Print("   Эквити: $", DoubleToString(Account.Equity(), 2));
      Print("   Сделок: ", TotalTrades);
      Print("   Win Rate: ", TotalTrades > 0 ? DoubleToString((double)WinTrades / TotalTrades * 100, 2) : "0.00", "%");
      Print("   Баров до автосохранения: ", SaveInterval - BarsSinceLastSave);
   }
}
//+------------------------------------------------------------------+
