自定义秒周期K线生成器（防闪烁版）

#property copyright "XAUOF指标工坊"
#property version   "2.00"
#property strict

//--- 输入参数
input string   InpSymbol       = "XAUUSD";     // 原始品种名称（必须存在于MT5中）
input int      InpPeriodSec    = 30;           // 自定义周期（秒），建议：15/30/45等能整除60的值
input int      InpBarsCount    = 10000;        // 加载的历史K线数量（建议500-2000）
input int      InpUpdateInterval = 1000;       // 当前K线更新间隔（毫秒），建议1000-3000，越大越流畅

//--- 全局变量
string   g_customSymbol = "";    // 自定义品种全名
datetime g_lastBarTime = 0;      // 上一根K线的时间
MqlRates g_currentBar;           // 当前正在构建的K线
bool     g_initialized = false;  // 是否已初始化
int      g_barCount = 0;         // 已生成的K线数量
int      g_tickCounter = 0;      // Tick计数器
double   g_lastValidPrice = 0;   // 上一个有效价格（用于异常检测）
bool     g_isFirstRun = false;   // 标记：是否首次运行（用于决定是否自动打开图表）
ulong    g_lastUpdateTime = 0;   // 上次更新当前K线的时间（毫秒）

//+------------------------------------------------------------------+
//| 专家初始化函数                                                      |
//+------------------------------------------------------------------+
int OnInit()
{
   // 1. 检查原始品种是否存在
   if(!SymbolSelect(InpSymbol, true))
   {
      Print("❌ 错误：品种 ", InpSymbol, " 不存在或无法选择");
      return INIT_FAILED;
   }
   
   // 强制订阅实时报价
   if(!SymbolSelect(InpSymbol, true))
   {
      Print("❌ 错误：无法订阅品种 ", InpSymbol, " 的实时报价");
      return INIT_FAILED;
   }
   
   // 等待报价准备就绪
   for(int i = 0; i < 10; i++)
   {
      MqlTick testTick;
      if(SymbolInfoTick(InpSymbol, testTick))
      {
         if(testTick.bid > 0)
            break;
      }
      Print("等待 ", InpSymbol, " 报价准备就绪...");
      Sleep(500);
   }
   
   // 验证当前报价
   MqlTick testTick;
   if(!SymbolInfoTick(InpSymbol, testTick))
   {
      Print("❌ 错误：无法获取品种 ", InpSymbol, " 的报价");
      return INIT_FAILED;
   }
   
   if(testTick.bid <= 0)
   {
      Print("❌ 错误：品种 ", InpSymbol, " 没有有效的bid报价");
      return INIT_FAILED;
   }
   
   g_lastValidPrice = testTick.bid;
   
   Print("✓ 品种 ", InpSymbol, " 当前价格：bid=", DoubleToString(testTick.bid, 2), 
         " ask=", DoubleToString(testTick.ask, 2));
   
   // 2. 检查周期参数合法性
   if(InpPeriodSec <= 0 || InpPeriodSec >= 60)
   {
      Print("❌ 错误：秒周期必须在 1-59 之间，当前值：", InpPeriodSec);
      return INIT_FAILED;
   }
   
   // 3. 构建自定义品种名称（格式：原品种_XXs）
   g_customSymbol = InpSymbol + "_" + IntegerToString(InpPeriodSec) + "s";
   
   // 4. 检查自定义品种是否已存在
   bool isCustom = false;
   bool symbolExists = SymbolExist(g_customSymbol, isCustom);
   
   if(symbolExists && isCustom)
   {
      // 品种已存在，说明不是首次运行
      g_isFirstRun = false;
      Print("✓ 检测到已存在的自定义品种：", g_customSymbol);
      Print("正在清空旧数据并重建...");
      
      // 清空历史数据
      datetime clearFrom = D'1970.01.01 00:00:00';
      datetime clearTo = TimeCurrent() + 86400;
      
      if(!CustomRatesDelete(g_customSymbol, clearFrom, clearTo))
      {
         int err = GetLastError();
         Print("⚠️ 清空旧数据失败，错误码：", err);
      }
      else
      {
         Print("✓ 已清空旧数据");
      }
      Sleep(100);
      
      // 重新生成历史K线
      if(!BuildHistoricalBars())
      {
         Print("⚠️ 警告：历史数据加载失败，将只处理实时tick");
         InitializeCurrentBar();
      }
      
      // 不自动打开图表，只在后台更新数据
      Print("✓ EA将在后台持续更新数据");
      Print("💡 如需查看图表：在市场报价中右键点击 ", g_customSymbol, " → 图表窗口");
   }
   else
   {
      // 品种不存在，首次运行
      g_isFirstRun = true;
      Print("✓ 首次运行，正在创建自定义品种...");
      
      // 创建新品种
      if(!CreateCustomSymbol())
         return INIT_FAILED;
      
      // 生成历史K线
      if(!BuildHistoricalBars())
      {
         Print("⚠️ 警告：历史数据加载失败，将只处理实时tick");
         InitializeCurrentBar();
      }
      
      // 首次运行：自动打开图表
      long chartID = ChartOpen(g_customSymbol, PERIOD_M1);
      if(chartID > 0)
      {
         Print("✅ 自动打开图表：", g_customSymbol, "，图表ID：", chartID);
         Sleep(300);
         ChartSetInteger(chartID, CHART_AUTOSCROLL, true);
         ChartSetInteger(chartID, CHART_BRING_TO_TOP, true);
         ChartRedraw(chartID);
      }
      else
      {
         Print("⚠️ 图表打开失败，请手动在市场报价中找到 ", g_customSymbol, " 并打开图表");
      }
   }
   
   // 5. 启动定时器（每10秒触发一次，用于心跳日志）
   EventSetTimer(10);
   
   g_initialized = true;
   Print("✅ 初始化完成：", g_customSymbol, "（", InpPeriodSec, "秒周期），已生成 ", g_barCount, " 根K线");
   Print("⚠️ 重要提示：EA将持续在后台更新数据，无论图表是否打开");
   Print("💡 更新间隔：", InpUpdateInterval, "毫秒（参数可调，越大越流畅，但实时性略降低）");
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 专家反初始化函数                                                    |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   
   // 退出前保存最后一根K线
   if(g_initialized && g_lastBarTime > 0)
   {
      MqlRates rates[1];
      rates[0] = g_currentBar;
      CustomRatesUpdate(g_customSymbol, rates, 1);
      Print("✓ 已保存最后一根K线");
   }
   
   Print("EA已停止，自定义品种 ", g_customSymbol, " 的数据已保存");
   Print("💡 提示：如需继续更新数据，请重新启动EA");
}

//+------------------------------------------------------------------+
//| 定时器事件（心跳日志）                                               |
//+------------------------------------------------------------------+
void OnTimer()
{
   if(!g_initialized) return;
   
   // 检查原始品种是否还在接收数据
   MqlTick tick;
   if(!SymbolInfoTick(InpSymbol, tick))
   {
      Print("⚠️ 警告：无法获取 ", InpSymbol, " 的报价，尝试重新订阅...");
      SymbolSelect(InpSymbol, true);
      return;
   }
   
   // 每10秒输出一次心跳日志
   static int heartbeat = 0;
   heartbeat++;
   
   if(heartbeat % 6 == 0)  // 每60秒输出一次
   {
      Print("💓 EA运行中... 已处理 ", g_tickCounter, " 个tick，当前K线数：", g_barCount, 
            "，最新K线时间：", TimeToString(g_lastBarTime, TIME_DATE|TIME_SECONDS),
            "，当前价格：", DoubleToString(tick.bid, 2));
   }
}

//+------------------------------------------------------------------+
//| 实时tick处理（核心优化：减少更新频率）                                  |
//+------------------------------------------------------------------+
void OnTick()
{
   if(!g_initialized) return;
   
   g_tickCounter++;
   
   // 获取原始品种的最新tick
   MqlTick tick;
   if(!SymbolInfoTick(InpSymbol, tick))
      return;
   
   // 使用bid价格（与标准图表一致）
   double price = tick.bid;
   
   // 严格的价格验证
   if(price <= 0.000001)
      return;
   
   // 异常价格检测：如果价格变化超过50%，很可能是错误数据
   if(g_lastValidPrice > 0)
   {
      double changePercent = MathAbs(price - g_lastValidPrice) / g_lastValidPrice * 100.0;
      if(changePercent > 50.0)
      {
         Print("⚠️ 检测到异常价格变化：", DoubleToString(changePercent, 2), 
               "%，从 ", DoubleToString(g_lastValidPrice, 2), 
               " 到 ", DoubleToString(price, 2), "，已忽略此tick");
         return;
      }
   }
   
   g_lastValidPrice = price;
   
   // 【关键优化1】每个tick都更新实时报价（轻量级操作，用于显示Ask/Bid线）
   UpdateCustomSymbolTick(tick);
   
   // 计算当前tick应该归属的K线时间
   datetime barTime = AlignTime(tick.time, InpPeriodSec);
   
   // 【关键优化2】如果是新K线，立即完成上一根K线
   if(barTime != g_lastBarTime && g_lastBarTime > 0)
   {
      // 写入上一根完成的K线（这是必须的，不能省略）
      MqlRates rates[1];
      rates[0] = g_currentBar;
      
      int result = CustomRatesUpdate(g_customSymbol, rates, 1);
      if(result == -1)
      {
         int err = GetLastError();
         Print("❌ K线更新失败，错误码：", err);
      }
      else
      {
         g_barCount++;
         Print("✓ 新K线 #", g_barCount, ": ", TimeToString(g_currentBar.time, TIME_DATE|TIME_SECONDS), 
               " O:", DoubleToString(g_currentBar.open, 2),
               " H:", DoubleToString(g_currentBar.high, 2),
               " L:", DoubleToString(g_currentBar.low, 2),
               " C:", DoubleToString(g_currentBar.close, 2));
      }
      
      // 初始化新K线
      g_currentBar.time = barTime;
      g_currentBar.open = price;
      g_currentBar.high = price;
      g_currentBar.low = price;
      g_currentBar.close = price;
      g_currentBar.tick_volume = 1;
      g_currentBar.spread = (int)((tick.ask - tick.bid) / SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
      g_currentBar.real_volume = 0;
      
      g_lastBarTime = barTime;
      g_lastUpdateTime = 0;  // 重置更新时间，新K线立即写入一次
   }
   else if(g_lastBarTime == 0)
   {
      // 第一次运行，初始化第一根K线
      g_currentBar.time = barTime;
      g_currentBar.open = price;
      g_currentBar.high = price;
      g_currentBar.low = price;
      g_currentBar.close = price;
      g_currentBar.tick_volume = 1;
      g_currentBar.spread = (int)((tick.ask - tick.bid) / SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
      g_currentBar.real_volume = 0;
      
      g_lastBarTime = barTime;
      g_lastUpdateTime = 0;
   }
   else
   {
      // 【关键优化3】更新当前K线数据（内存中）
      if(price > g_currentBar.high) g_currentBar.high = price;
      if(price < g_currentBar.low) g_currentBar.low = price;
      g_currentBar.close = price;
      g_currentBar.tick_volume++;
      g_currentBar.spread = (int)((tick.ask - tick.bid) / SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
      
      // 【关键优化4】节流：只在达到更新间隔时才写入当前K线
      ulong currentTime = GetTickCount64();
      if(g_lastUpdateTime == 0 || (currentTime - g_lastUpdateTime) >= (ulong)InpUpdateInterval)
      {
         MqlRates rates[1];
         rates[0] = g_currentBar;
         CustomRatesUpdate(g_customSymbol, rates, 1);
         g_lastUpdateTime = currentTime;
      }
      // 如果未到更新间隔，跳过写入，只更新内存中的数据
   }
}

//+------------------------------------------------------------------+
//| 更新自定义品种的实时报价（用于显示Ask/Bid线）                           |
//+------------------------------------------------------------------+
void UpdateCustomSymbolTick(const MqlTick &sourceTick)
{
   MqlTick customTick;
   customTick.time = sourceTick.time;
   customTick.bid = sourceTick.bid;
   customTick.ask = sourceTick.ask > 0 ? sourceTick.ask : sourceTick.bid;
   customTick.last = sourceTick.last > 0 ? sourceTick.last : sourceTick.bid;
   customTick.volume = sourceTick.volume;
   customTick.time_msc = sourceTick.time_msc;
   customTick.flags = sourceTick.flags;
   customTick.volume_real = sourceTick.volume_real;
   
   // 更新自定义品种的tick（轻量级操作，不会触发K线重绘）
   MqlTick tickArray[1];
   tickArray[0] = customTick;
   
   CustomTicksAdd(g_customSymbol, tickArray, 1);
}

//+------------------------------------------------------------------+
//| 初始化当前K线                                                      |
//+------------------------------------------------------------------+
void InitializeCurrentBar()
{
   MqlTick tick;
   if(!SymbolInfoTick(InpSymbol, tick))
      return;
   
   double price = tick.bid;
   if(price <= 0)
      return;
   
   datetime barTime = AlignTime(tick.time, InpPeriodSec);
   
   g_currentBar.time = barTime;
   g_currentBar.open = price;
   g_currentBar.high = price;
   g_currentBar.low = price;
   g_currentBar.close = price;
   g_currentBar.tick_volume = 1;
   g_currentBar.spread = (int)((tick.ask - tick.bid) / SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
   g_currentBar.real_volume = 0;
   
   g_lastBarTime = barTime;
   g_lastValidPrice = price;
   
   // 写入初始K线
   MqlRates rates[1];
   rates[0] = g_currentBar;
   CustomRatesUpdate(g_customSymbol, rates, 1);
   g_barCount = 1;
   
   Print("✓ 已初始化起始K线：", TimeToString(barTime, TIME_DATE|TIME_SECONDS), " 价格：", DoubleToString(price, 2));
}

//+------------------------------------------------------------------+
//| 创建自定义品种                                                      |
//+------------------------------------------------------------------+
bool CreateCustomSymbol()
{
   // 创建新的自定义品种
   if(!CustomSymbolCreate(g_customSymbol, "", InpSymbol))
   {
      int err = GetLastError();
      Print("❌ 创建自定义品种失败，错误码：", err);
      return false;
   }
   
   Print("✓ 创建自定义品种：", g_customSymbol);
   
   // 复制原始品种的属性
   long digits = SymbolInfoInteger(InpSymbol, SYMBOL_DIGITS);
   CustomSymbolSetInteger(g_customSymbol, SYMBOL_DIGITS, digits);
   CustomSymbolSetInteger(g_customSymbol, SYMBOL_TRADE_CALC_MODE, SymbolInfoInteger(InpSymbol, SYMBOL_TRADE_CALC_MODE));
   CustomSymbolSetDouble(g_customSymbol, SYMBOL_POINT, SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
   CustomSymbolSetDouble(g_customSymbol, SYMBOL_TRADE_TICK_SIZE, SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_TICK_SIZE));
   CustomSymbolSetDouble(g_customSymbol, SYMBOL_TRADE_TICK_VALUE, SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_TICK_VALUE));
   CustomSymbolSetDouble(g_customSymbol, SYMBOL_TRADE_CONTRACT_SIZE, SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_CONTRACT_SIZE));
   CustomSymbolSetInteger(g_customSymbol, SYMBOL_SPREAD, SymbolInfoInteger(InpSymbol, SYMBOL_SPREAD));
   CustomSymbolSetString(g_customSymbol, SYMBOL_CURRENCY_BASE, SymbolInfoString(InpSymbol, SYMBOL_CURRENCY_BASE));
   CustomSymbolSetString(g_customSymbol, SYMBOL_CURRENCY_PROFIT, SymbolInfoString(InpSymbol, SYMBOL_CURRENCY_PROFIT));
   CustomSymbolSetString(g_customSymbol, SYMBOL_DESCRIPTION, SymbolInfoString(InpSymbol, SYMBOL_DESCRIPTION) + " (" + IntegerToString(InpPeriodSec) + "s)");
   
   Print("✓ 品种属性设置完成，小数位：", digits);
   return true;
}

//+------------------------------------------------------------------+
//| 构建历史K线数据                                                     |
//+------------------------------------------------------------------+
bool BuildHistoricalBars()
{
   Print("========== 开始构建历史K线 ==========");
   Print("目标K线数：", InpBarsCount);
   
   // 计算需要获取的tick时间范围
   datetime toTime = TimeCurrent();
   datetime fromTime = toTime - (InpBarsCount * InpPeriodSec) - 7200;
   
   Print("时间范围：", TimeToString(fromTime, TIME_DATE|TIME_SECONDS), " 至 ", TimeToString(toTime, TIME_DATE|TIME_SECONDS));
   
   // 获取历史tick数据
   MqlTick ticks[];
   int tickCount = CopyTicksRange(InpSymbol, ticks, COPY_TICKS_ALL, (long)fromTime * 1000, (long)toTime * 1000);
   
   if(tickCount <= 0)
   {
      Print("❌ 无法获取历史tick数据，错误码：", GetLastError());
      Print("提示：某些券商不提供历史tick，将只处理实时数据");
      return false;
   }
   
   Print("✓ 获取到 ", tickCount, " 个历史tick");
   
   // 聚合成K线
   MqlRates bars[];
   ArrayResize(bars, 0);
   ArraySetAsSeries(bars, false);
   
   datetime currentBarTime = 0;
   MqlRates tempBar;
   int validTickCount = 0;
   double lastPrice = 0;
   
   for(int i = 0; i < tickCount; i++)
   {
      // 使用bid价格（与标准图表一致）
      double price = ticks[i].bid;
      
      // 跳过无效价格
      if(price <= 0.000001) continue;
      
      // 异常价格检测
      if(lastPrice > 0)
      {
         double changePercent = MathAbs(price - lastPrice) / lastPrice * 100.0;
         if(changePercent > 50.0)
         {
            continue;
         }
      }
      
      lastPrice = price;
      validTickCount++;
      
      datetime barTime = AlignTime(ticks[i].time, InpPeriodSec);
      
      // 新K线
      if(barTime != currentBarTime)
      {
         // 保存上一根K线
         if(currentBarTime > 0)
         {
            int size = ArraySize(bars);
            ArrayResize(bars, size + 1);
            bars[size] = tempBar;
         }
         
         // 初始化新K线
         tempBar.time = barTime;
         tempBar.open = price;
         tempBar.high = price;
         tempBar.low = price;
         tempBar.close = price;
         tempBar.tick_volume = 1;
         tempBar.spread = (int)((ticks[i].ask - ticks[i].bid) / SymbolInfoDouble(InpSymbol, SYMBOL_POINT));
         tempBar.real_volume = 0;
         
         currentBarTime = barTime;
      }
      else
      {
         // 更新当前K线
         if(price > tempBar.high) tempBar.high = price;
         if(price < tempBar.low) tempBar.low = price;
         tempBar.close = price;
         tempBar.tick_volume++;
      }
   }
   
   // 保存最后一根K线
   if(currentBarTime > 0)
   {
      int size = ArraySize(bars);
      ArrayResize(bars, size + 1);
      bars[size] = tempBar;
   }
   
   int totalBars = ArraySize(bars);
   
   if(totalBars == 0)
   {
      Print("❌ 未能生成任何K线数据（有效tick数：", validTickCount, "）");
      return false;
   }
   
   Print("✓ 聚合完成，共生成 ", totalBars, " 根K线（有效tick数：", validTickCount, "）");
   
   // 截取到指定数量（保留最新的）
   int startIdx = 0;
   if(totalBars > InpBarsCount)
   {
      startIdx = totalBars - InpBarsCount;
      Print("✓ 截取最新 ", InpBarsCount, " 根K线（从索引 ", startIdx, " 开始）");
   }
   
   MqlRates finalBars[];
   int finalCount = totalBars - startIdx;
   ArrayResize(finalBars, finalCount);
   ArrayCopy(finalBars, bars, 0, startIdx, finalCount);
   
   // 使用 CustomRatesReplace 整体写入
   int result = CustomRatesReplace(g_customSymbol, finalBars[0].time, finalBars[finalCount - 1].time + InpPeriodSec, finalBars, finalCount);
   
   if(result == -1)
   {
      int err = GetLastError();
      Print("❌ 历史K线写入失败，错误码：", err);
      return false;
   }
   
   Print("✅ 成功写入 ", finalCount, " 根历史K线到自定义品种");
   Print("历史K线时间范围：", TimeToString(finalBars[0].time, TIME_DATE|TIME_SECONDS), 
         " 至 ", TimeToString(finalBars[finalCount - 1].time, TIME_DATE|TIME_SECONDS));
   
   // 记录最后一根K线
   g_lastBarTime = finalBars[finalCount - 1].time;
   g_currentBar = finalBars[finalCount - 1];
   g_barCount = finalCount;
   g_lastValidPrice = finalBars[finalCount - 1].close;
   
   return true;
}

//+------------------------------------------------------------------+
//| 时间对齐函数                                                       |
//+------------------------------------------------------------------+
datetime AlignTime(datetime tickTime, int periodSec)
{
   MqlDateTime dt;
   TimeToStruct(tickTime, dt);
   
   int secInMinute = dt.sec;
   int barNumber = secInMinute / periodSec;
   int alignedSec = barNumber * periodSec;
   
   dt.sec = alignedSec;
   
   return StructToTime(dt);
}
//+------------------------------------------------------------------+