//+------------------------------------------------------------------+
//|                                       MultiSymbolManager.mqh     |
//|                          Copyright 2026, 晓辉编程 (eafxtech.com)  |
//|                                             https://www.eafxtech.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, 晓辉编程"
#property link      "https://www.eafxtech.com"
#property version   "1.00"

// 单品种信息结构体
struct SymbolInfoEx
{
   string   name;          // 券商实际符号名（如EURUSDm）
   string   baseName;      // 基础名称（如EURUSD）
   double   point;         // 点值（如0.00001）
   int      digits;        // 小数位数
   double   volumeMin;     // 最小手数
   double   volumeMax;     // 最大手数
   double   volumeStep;    // 手数步进
   double   contractSize;  // 合约大小
   bool     tradeable;     // 是否可交易
};

//+------------------------------------------------------------------+
//| 多品种符号管理器类                                                 |
//+------------------------------------------------------------------+
class CMultiSymbolManager
{
private:
   SymbolInfoEx  m_symbols[];      // 符号列表
   int           m_count;          // 有效符号数量
   string        m_baseList;       // 基础名称列表（逗号分隔）

   // 查找符号的实际名称（自动识别后缀）
   string        FindRealSymbol(string baseName);
   // 加载符号详细属性
   bool          LoadSymbolProps(int index);

public:
                 CMultiSymbolManager();
                ~CMultiSymbolManager();

   // 初始化：传入基础品种列表（如"EURUSD,GBPUSD,USDJPY"）
   bool          Init(string symbolList);
   // 获取有效符号数量
   int           GetCount() const       { return m_count; }
   // 获取符号名（按索引）
   string        GetName(int index) const;
   // 获取基础名
   string        GetBaseName(int index) const;
   // 获取点值
   double        GetPoint(int index) const;
   // 获取小数位数
   int           GetDigits(int index) const;
   // 获取最小手数
   double        GetVolumeMin(int index) const;
   // 获取手数步进
   double        GetVolumeStep(int index) const;
   // 获取合约大小
   double        GetContractSize(int index) const;
   // 是否可交易
   bool          IsTradeable(int index) const;
   // 根据基础名查找索引
   int           FindByBaseName(string baseName) const;
};

//+------------------------------------------------------------------+
//| 构造函数                                                          |
//+------------------------------------------------------------------+
CMultiSymbolManager::CMultiSymbolManager()
{
   m_count = 0;
   ArrayResize(m_symbols, 50); // 预分配空间
}

//+------------------------------------------------------------------+
//| 析构函数                                                          |
//+------------------------------------------------------------------+
CMultiSymbolManager::~CMultiSymbolManager()
{
}

//+------------------------------------------------------------------+
//| 查找实际符号名（自动识别券商后缀）                                  |
//+------------------------------------------------------------------+
string CMultiSymbolManager::FindRealSymbol(string baseName)
{
   int total = SymbolsTotal(false); // 全市场符号
   string bestMatch = "";
   int bestMatchLen = 999;

   for(int i = 0; i < total; i++)
   {
      string name = SymbolName(i, false);
      // 检查是否以基础名开头
      if(StringFind(name, baseName, 0) == 0)
      {
         int len = StringLen(name);
         // 选最短的匹配（后缀最少的最可能是标准品种）
         if(len < bestMatchLen && len >= StringLen(baseName))
         {
            bestMatchLen = len;
            bestMatch = name;
         }
      }
   }

   return bestMatch;
}

//+------------------------------------------------------------------+
//| 加载符号详细属性                                                  |
//+------------------------------------------------------------------+
bool CMultiSymbolManager::LoadSymbolProps(int index)
{
   if(index < 0 || index >= m_count) return false;

   string name = m_symbols[index].name;

   // 确保符号在市场观察中
   if(!SymbolSelect(name, true))
      return false;

   // 等待符号数据就绪（最多等待2秒）
   int timeout = 2000;
   while(!SymbolInfoDouble(name, SYMBOL_BID) && timeout > 0)
   {
      Sleep(10);
      timeout -= 10;
   }

   // 加载各项属性
   m_symbols[index].point        = SymbolInfoDouble(name, SYMBOL_POINT);
   m_symbols[index].digits       = (int)SymbolInfoInteger(name, SYMBOL_DIGITS);
   m_symbols[index].volumeMin    = SymbolInfoDouble(name, SYMBOL_VOLUME_MIN);
   m_symbols[index].volumeMax    = SymbolInfoDouble(name, SYMBOL_VOLUME_MAX);
   m_symbols[index].volumeStep   = SymbolInfoDouble(name, SYMBOL_VOLUME_STEP);
   m_symbols[index].contractSize = SymbolInfoDouble(name, SYMBOL_TRADE_CONTRACT_SIZE);

   // 检查是否可交易
   int tradeMode = (int)SymbolInfoInteger(name, SYMBOL_TRADE_MODE);
   m_symbols[index].tradeable = (tradeMode == SYMBOL_TRADE_MODE_FULL);

   return true;
}

//+------------------------------------------------------------------+
//| 初始化                                                            |
//+------------------------------------------------------------------+
bool CMultiSymbolManager::Init(string symbolList)
{
   m_baseList = symbolList;
   m_count = 0;

   // 分割基础名称列表
   string baseNames[];
   int num = StringSplit(symbolList, ",", baseNames);

   if(num == 0)
   {
      Print("符号列表为空，初始化失败");
      return false;
   }

   ArrayResize(m_symbols, num);

   // 逐个查找并加载
   for(int i = 0; i < num; i++)
   {
      string baseName = baseNames[i];
      string realName = FindRealSymbol(baseName);

      if(realName == "")
      {
         Print("未找到品种: ", baseName, "，跳过");
         continue;
      }

      m_symbols[m_count].name = realName;
      m_symbols[m_count].baseName = baseName;

      if(LoadSymbolProps(m_count))
      {
         Print("已加载品种: ", baseName, " -> ", realName,
               " 点值:", DoubleToString(m_symbols[m_count].point, m_symbols[m_count].digits),
               " 最小手数:", m_symbols[m_count].volumeMin,
               " 可交易:", m_symbols[m_count].tradeable);
         m_count++;
      }
      else
      {
         Print("加载品种失败: ", realName);
      }
   }

   return (m_count > 0);
}

//+------------------------------------------------------------------+
//| 以下为各属性的Getter方法（略去重复，仅展示关键几个）                |
//+------------------------------------------------------------------+
string CMultiSymbolManager::GetName(int index) const
{
   if(index < 0 || index >= m_count) return "";
   return m_symbols[index].name;
}

double CMultiSymbolManager::GetPoint(int index) const
{
   if(index < 0 || index >= m_count) return 0;
   return m_symbols[index].point;
}

double CMultiSymbolManager::GetVolumeStep(int index) const
{
   if(index < 0 || index >= m_count) return 0.01;
   return m_symbols[index].volumeStep;
}

int CMultiSymbolManager::FindByBaseName(string baseName) const
{
   for(int i = 0; i < m_count; i++)
      if(m_symbols[i].baseName == baseName)
         return i;
   return -1;
}

//+------------------------------------------------------------------+
//|                                          FundAllocator.mqh       |
//|                          Copyright 2026, 晓辉编程 (eafxtech.com)  |
//|                                             https://www.eafxtech.com |
//+------------------------------------------------------------------+

// 分配模式枚举
enum ENUM_ALLOC_MODE
{
   ALLOC_EQUAL,         // 等权分配
   ALLOC_RISK_PARITY,   // 风险平价
   ALLOC_KELLY          // 凯利公式（简化版）
};

//+------------------------------------------------------------------+
//| 资金分配器类                                                       |
//+------------------------------------------------------------------+
class CFundAllocator
{
private:
   ENUM_ALLOC_MODE  m_mode;           // 分配模式
   double           m_riskPercent;    // 账户风险比例（如0.02表示2%）
   double           m_weights[];      // 各品种权重
   int              m_count;          // 品种数量
   double           m_atr[];          // 各品种ATR
   double           m_expectedReturn[]; // 各品种期望收益率（凯利模式用）

   // 计算等权权重
   void            CalcEqualWeights();
   // 计算风险平价权重
   void            CalcRiskParityWeights();
   // 计算凯利权重
   void            CalcKellyWeights();
   // 归一化权重（使和为1）
   void            NormalizeWeights();
   // 对齐券商手数步进
   double          AlignVolume(double volume, double volumeStep, double volumeMin, double volumeMax);

public:
                    CFundAllocator();
                   ~CFundAllocator();

   // 初始化
   bool            Init(ENUM_ALLOC_MODE mode, double riskPercent, int symbolCount);
   // 设置品种ATR（风险平价和凯利模式需要）
   void            SetATR(int index, double atr);
   // 设置品种期望收益率（凯利模式需要，如0.001表示0.1%）
   void            SetExpectedReturn(int index, double ret);
   // 重新计算权重（参数变化后调用）
   void            Recalculate();
   // 获取目标手数
   double          GetTargetLot(int index, double balance, double stopLossPoints,
                               double pointValue, double volumeStep,
                               double volumeMin, double volumeMax);
   // 获取权重
   double          GetWeight(int index) const;
};

//+------------------------------------------------------------------+
//| 计算等权权重                                                      |
//+------------------------------------------------------------------+
void CFundAllocator::CalcEqualWeights()
{
   if(m_count == 0) return;
   for(int i = 0; i < m_count; i++)
      m_weights[i] = 1.0 / m_count;
}

//+------------------------------------------------------------------+
//| 计算风险平价权重                                                   |
//+------------------------------------------------------------------+
void CFundAllocator::CalcRiskParityWeights()
{
   if(m_count == 0) return;

   double sumInverse = 0;
   double risk[];
   ArrayResize(risk, m_count);

   // 计算波动率倒数之和
   for(int i = 0; i < m_count; i++)
   {
      double vol = (m_atr[i] > 0) ? m_atr[i] : 0.0001;
      risk[i] = 1.0 / vol;
      sumInverse += risk[i];
   }

   // 归一化
   if(sumInverse > 0)
   {
      for(int i = 0; i < m_count; i++)
         m_weights[i] = risk[i] / sumInverse;
   }
   else
   {
      CalcEqualWeights();
   }
}

//+------------------------------------------------------------------+
//| 计算凯利权重（简化版，对角线近似）                                  |
//+------------------------------------------------------------------+
void CFundAllocator::CalcKellyWeights()
{
   if(m_count == 0) return;

   double kelly[];
   ArrayResize(kelly, m_count);
   double sumKelly = 0;

   for(int i = 0; i < m_count; i++)
   {
      double vol = (m_atr[i] > 0) ? m_atr[i] : 0.0001;
      double ret = m_expectedReturn[i];
      // f = mu / sigma^2，取绝对值后归一化
      kelly[i] = MathAbs(ret) / (vol * vol);
      // 分数凯利：乘以0.5
      kelly[i] *= 0.5;
      sumKelly += kelly[i];
   }

   if(sumKelly > 0)
   {
      for(int i = 0; i < m_count; i++)
         m_weights[i] = kelly[i] / sumKelly;
   }
   else
   {
      CalcEqualWeights();
   }
}

//+------------------------------------------------------------------+
//| 重新计算所有权重                                                   |
//+------------------------------------------------------------------+
void CFundAllocator::Recalculate()
{
   switch(m_mode)
   {
      case ALLOC_EQUAL:
         CalcEqualWeights();
         break;
      case ALLOC_RISK_PARITY:
         CalcRiskParityWeights();
         break;
      case ALLOC_KELLY:
         CalcKellyWeights();
         break;
   }
}

//+------------------------------------------------------------------+
//| 对齐手数到券商规格                                                 |
//+------------------------------------------------------------------+
double CFundAllocator::AlignVolume(double volume, double volumeStep,
                                   double volumeMin, double volumeMax)
{
   if(volumeStep <= 0) volumeStep = 0.01;

   // 按步进取整
   double steps = MathFloor(volume / volumeStep);
   double aligned = steps * volumeStep;

   // 限制在最小/最大范围内
   if(aligned < volumeMin) aligned = volumeMin;
   if(aligned > volumeMax) aligned = volumeMax;

   return aligned;
}

//+------------------------------------------------------------------+
//| 获取目标手数                                                      |
//+------------------------------------------------------------------+
double CFundAllocator::GetTargetLot(int index, double balance,
                                    double stopLossPoints,
                                    double pointValue,
                                    double volumeStep,
                                    double volumeMin,
                                    double volumeMax)
{
   if(index < 0 || index >= m_count) return 0;
   if(balance <= 0 || stopLossPoints <= 0 || pointValue <= 0) return 0;

   // 总风险金额 = 账户资金 × 风险比例
   double totalRisk = balance * m_riskPercent;
   // 该品种分配的风险金额 = 总风险 × 权重
   double symbolRisk = totalRisk * m_weights[index];
   // 每手每点盈亏金额 = 合约大小 × 点值（注意：pointValue是1标准手1点的盈亏）
   double perLotPerPoint = pointValue;
   // 目标手数 = 风险金额 / (止损点数 × 每手每点盈亏)
   double targetLot = symbolRisk / (stopLossPoints * perLotPerPoint);

   // 对齐券商手数规格
   targetLot = AlignVolume(targetLot, volumeStep, volumeMin, volumeMax);

   return targetLot;
}

//+------------------------------------------------------------------+
//|                                         CrossSignalEngine.mqh    |
//|                          Copyright 2026, 晓辉编程 (eafxtech.com)  |
//|                                             https://www.eafxtech.com |
//+------------------------------------------------------------------+

// 信号结构体
struct TradeSignal
{
   string   symbol;      // 符号名
   int      direction;   // 1=做多, -1=做空, 0=无信号
   double   strength;    // 信号强度（0-100）
   double   entryPrice;  // 入场价
   double   stopLoss;    // 止损价
   double   takeProfit;  // 止盈价
   bool     filtered;    // 是否已被过滤
};

//+------------------------------------------------------------------+
//| 跨品种信号引擎类                                                   |
//+------------------------------------------------------------------+
class CCrossSignalEngine
{
private:
   int              m_count;              // 品种数量
   string           m_symbols[];          // 品种列表
   double           m_corrMatrix[];       // 相关系数矩阵（一维存储）
   int              m_corrPeriod;         // 相关性回看周期（K线数）
   ENUM_TIMEFRAMES  m_corrTimeframe;      // 相关性计算时间帧

   // 获取矩阵索引
   int             MatrixIndex(int i, int j) const;

public:
                    CCrossSignalEngine();
                   ~CCrossSignalEngine();

   // 初始化
   bool            Init(string symbolList, int corrPeriod=60,
                        ENUM_TIMEFRAMES corrTimeframe=PERIOD_D1);
   // 计算两品种相关系数
   double          CalcCorrelation(string symbolA, string symbolB) const;
   // 更新整个相关系数矩阵
   bool            UpdateCorrelationMatrix();
   // 按动量对品种排序（返回排序后的索引数组）
   void            RankByMomentum(int &sortedIndexes[], int &count,
                                  ENUM_TIMEFRAMES timeframe, int momentumPeriod) const;
   // 基于相关性过滤重复信号（同方向高相关品种只留最强的）
   int             FilterSignals(TradeSignal &signals[], int count,
                                 double corrThreshold=0.7);
   // 获取相关系数
   double          GetCorrelation(int i, int j) const;
};

//+------------------------------------------------------------------+
//| 计算两品种的皮尔逊相关系数                                          |
//+------------------------------------------------------------------+
double CCrossSignalEngine::CalcCorrelation(string symbolA, string symbolB) const
{
   // 获取两个品种的收盘价数组
   double closeA[], closeB[];
   int copiedA = CopyClose(symbolA, m_corrTimeframe, 0, m_corrPeriod, closeA);
   int copiedB = CopyClose(symbolB, m_corrTimeframe, 0, m_corrPeriod, closeB);

   if(copiedA < m_corrPeriod || copiedB < m_corrPeriod)
      return 0.0;

   // 计算收益率（对数收益率）
   double retA[], retB[];
   ArrayResize(retA, m_corrPeriod - 1);
   ArrayResize(retB, m_corrPeriod - 1);

   for(int i = 0; i < m_corrPeriod - 1; i++)
   {
      retA[i] = MathLog(closeA[i] / closeA[i+1]);
      retB[i] = MathLog(closeB[i] / closeB[i+1]);
   }

   // 计算均值
   double meanA = 0, meanB = 0;
   int n = m_corrPeriod - 1;
   for(int i = 0; i < n; i++)
   {
      meanA += retA[i];
      meanB += retB[i];
   }
   meanA /= n;
   meanB /= n;

   // 计算协方差和方差
   double cov = 0, varA = 0, varB = 0;
   for(int i = 0; i < n; i++)
   {
      double da = retA[i] - meanA;
      double db = retB[i] - meanB;
      cov += da * db;
      varA += da * da;
      varB += db * db;
   }

   // 相关系数 = 协方差 / (标准差A × 标准差B)
   double denom = MathSqrt(varA * varB);
   if(denom == 0) return 0.0;

   return cov / denom;
}

//+------------------------------------------------------------------+
//| 相关性过滤：同方向高相关品种只保留最强的信号                         |
//+------------------------------------------------------------------+
int CCrossSignalEngine::FilterSignals(TradeSignal &signals[], int count,
                                       double corrThreshold)
{
   // 先按信号强度排序（从强到弱）
   for(int i = 0; i < count - 1; i++)
      for(int j = i + 1; j < count; j++)
         if(signals[j].strength > signals[i].strength)
         {
            TradeSignal temp = signals[i];
            signals[i] = signals[j];
            signals[j] = temp;
         }

   int filteredCount = 0;

   // 遍历所有信号对
   for(int i = 0; i < count; i++)
   {
      if(signals[i].filtered || signals[i].direction == 0)
         continue;

      filteredCount++;

      // 标记与当前信号同方向且高度相关的其他信号为已过滤
      for(int j = i + 1; j < count; j++)
      {
         if(signals[j].filtered || signals[j].direction == 0)
            continue;

         // 只过滤同方向的信号
         if(signals[j].direction != signals[i].direction)
            continue;

         // 查找两个品种在列表中的索引
         int idxA = -1, idxB = -1;
         for(int k = 0; k < m_count; k++)
         {
            if(m_symbols[k] == signals[i].symbol) idxA = k;
            if(m_symbols[k] == signals[j].symbol) idxB = k;
         }

         if(idxA == -1 || idxB == -1) continue;

         double corr = GetCorrelation(idxA, idxB);

         // 如果相关系数超过阈值，过滤掉较弱的那个
         if(corr >= corrThreshold)
         {
            signals[j].filtered = true;
         }
      }
   }

   return filteredCount;
}

//+------------------------------------------------------------------+
//| OnTick 主流程（伪代码）                                            |
//+------------------------------------------------------------------+
void OnTick()
{
   // === 第0步：新K线检查 ===
   // 只在新K线出现时执行策略逻辑，减少不必要的计算
   static datetime lastBarTime = 0;
   datetime currentBarTime = iTime(_Symbol, _Period, 0);
   if(currentBarTime == lastBarTime) return;
   lastBarTime = currentBarTime;

   // === 第1步：行情更新 ===
   // 遍历所有品种，获取最新价格和指标值
   for(int i = 0; i < symbolMgr.GetCount(); i++)
   {
      string symbol = symbolMgr.GetName(i);
      // 更新MA、RSI等指标值
      UpdateIndicators(symbol);
      // 更新ATR（给资金分配器用）
      double atr = iATR(symbol, _Period, ATR_PERIOD, 0);
      allocator.SetATR(i, atr);
   }

   // === 第2步：资金分配权重更新（每日一次即可） ===
   static int lastDay = -1;
   int today = TimeDay(TimeCurrent());
   if(today != lastDay)
   {
      allocator.Recalculate();
      signalEngine.UpdateCorrelationMatrix();
      lastDay = today;
   }

   // === 第3步：信号生成 ===
   // 各品种独立产生交易信号
   TradeSignal signals[];
   int signalCount = 0;
   ArrayResize(signals, symbolMgr.GetCount());

   for(int i = 0; i < symbolMgr.GetCount(); i++)
   {
      string symbol = symbolMgr.GetName(i);

      // 检查该品种是否被熔断
      if(riskManager.IsSymbolHalted(symbol))
         continue;

      // 生成信号（示例：均线金叉死叉）
      int direction = GenerateSignal(symbol);

      if(direction != 0)
      {
         signals[signalCount].symbol = symbol;
         signals[signalCount].direction = direction;
         signals[signalCount].strength = CalcSignalStrength(symbol, direction);
         signals[signalCount].entryPrice = GetEntryPrice(symbol, direction);
         signals[signalCount].stopLoss = GetStopLoss(symbol, direction);
         signals[signalCount].takeProfit = GetTakeProfit(symbol, direction);
         signals[signalCount].filtered = false;
         signalCount++;
      }
   }

   // === 第4步：信号过滤 ===
   // 跨品种相关性过滤
   if(signalCount > 1)
   {
      signalEngine.FilterSignals(signals, signalCount, 0.7);
   }

   // === 第5步：执行订单 ===
   for(int i = 0; i < signalCount; i++)
   {
      if(signals[i].filtered || signals[i].direction == 0)
         continue;

      string symbol = signals[i].symbol;

      // 检查该品种是否已有持仓（简单策略每个品种只持一单）
      if(PositionSelect(symbol))
         continue;

      // 计算目标手数
      double slPoints = MathAbs(signals[i].entryPrice - signals[i].stopLoss)
                        / SymbolInfoDouble(symbol, SYMBOL_POINT);
      double pointValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE)
                         / SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE)
                         * SymbolInfoDouble(symbol, SYMBOL_POINT);
      int idx = symbolMgr.FindByBaseName(GetBaseName(symbol));
      double lot = allocator.GetTargetLot(
         idx,
         AccountInfoDouble(ACCOUNT_BALANCE),
         slPoints,
         pointValue,
         symbolMgr.GetVolumeStep(idx),
         symbolMgr.GetVolumeMin(idx),
         symbolMgr.GetVolumeMax(idx)
      );

      // 账户级风控检查
      if(!riskManager.CheckAccountRisk(symbol, lot, signals[i].direction))
         continue;

      // 下单
      if(signals[i].direction == 1)
         trade.Buy(lot, symbol, signals[i].entryPrice,
                   signals[i].stopLoss, signals[i].takeProfit, "MultiSymbolTrend");
      else
         trade.Sell(lot, symbol, signals[i].entryPrice,
                    signals[i].stopLoss, signals[i].takeProfit, "MultiSymbolTrend");
   }

   // === 第6步：持仓风控检查 ===
   riskManager.CheckAllPositions();
}