#property copyright "Vyacheslav Barbakov | 4_PLC | 28 февраля 2012 года"
#property link      "barbakov@bk.ru"
//+-----------------------------------------------------------------------------------------------------------+
//| Внешние переменные, вводимые перед запуском советника                                                     |
//+-----------------------------------------------------------------------------------------------------------+
  extern   int       MagicNumber                    =     0;
  extern   int       spred_razmer                   =     15;
  extern   int       filtr_razmer                   =     23;
  extern   double    profit_close                   =     7;
  extern   double    filtr_otstup_no_orders         =     43;
  extern   double    razmer_order_buy               =     0.01;
  extern   double    razmer_order_sell              =     0.01;
  extern   int       x5min                          =     2;
  extern   int       x60min                         =     4;

//+-----------------------------------------------------------------------------------------------------------+
  double spread;
  bool   close_all = false;
//+-----------------------------------------------------------------------------------------------------------+
int init()
{ // начало процедуры init()
  return(0);
} // конец процедуры init()
           
//+-----------------------------------------------------------------------------------------------------------+
//| Тело программы обработки каждого тика start()                                                             |
//+-----------------------------------------------------------------------------------------------------------+
int start()
{ // начало процедуры start()
//+-----------------------------------------------------------------------------------------------------------+
//| Инициализация переменных
//+-----------------------------------------------------------------------------------------------------------+
         double buy_orders_price [];
         double sell_orders_price [];
  if (OrdersTotal()!=0)
  {
    ArrayInitialize (buy_orders_price, 0);
    ArrayInitialize (sell_orders_price, 0);
  }
//+-----------------------------------------------------------------------------------------------------------+
//| Ищем ближайшие фракталы на 5 минутном  графике
//+-----------------------------------------------------------------------------------------------------------+
  double fractal_5min_hi, fractal_5min_low; 
  int f_5min_hi =0;
  while(fractal_5min_hi == 0)
  {
    fractal_5min_hi = iFractals(NULL,5, 1, f_5min_hi);
    f_5min_hi++;
  }

  int f_5min_low =0;
  while(fractal_5min_low == 0)
  {
    fractal_5min_low = iFractals(NULL, 5, 2, f_5min_low);
    f_5min_low++;
  }
//+-----------------------------------------------------------------------------------------------------------+
//| Ищем ближайшие фракталы на 15 минутном таймфрэйме
//+-----------------------------------------------------------------------------------------------------------+
  double fractal_15min_hi, fractal_15min_low; 
  int f_15min_hi =0;
  while(fractal_15min_hi == 0)
  {
    fractal_15min_hi = iFractals(NULL,15, 1, f_15min_hi);
    f_15min_hi++;
  }

  int f_15min_low =0;
  while(fractal_15min_low == 0)
  {
    fractal_15min_low = iFractals(NULL, 15, 2, f_15min_low);
    f_15min_low++;
  }
 //+-----------------------------------------------------------------------------------------------------------+
//| Ищем ближайшие фракталы на 30 минутном таймфрэйме
//+-----------------------------------------------------------------------------------------------------------+
  double fractal_30min_hi, fractal_30min_low; 
  int f_30min_hi =0;
  while(fractal_30min_hi == 0)
  {
    fractal_30min_hi = iFractals(NULL,30, 1, f_30min_hi);
    f_30min_hi++;
  }

  int f_30min_low =0;
  while(fractal_30min_low == 0)
  {
    fractal_30min_low = iFractals(NULL, 30, 2, f_30min_low);
    f_30min_low++;
  }
//+-----------------------------------------------------------------------------------------------------------+
//| Ищем ближайшие фракталы на 60 минутном таймфрэйме
//+-----------------------------------------------------------------------------------------------------------+
  double fractal_60min_hi, fractal_60min_low; 
  int f_60min_hi =0;
  while(fractal_60min_hi == 0)
  {
    fractal_60min_hi = iFractals(NULL, 60, 1, f_60min_hi);
    f_60min_hi++;
  }

  int f_60min_low =0;
  while(fractal_60min_low == 0)
  {
    fractal_60min_low = iFractals(NULL, 60, 2, f_60min_low);
    f_60min_low++;
  }
//+-----------------------------------------------------------------------------------------------------------+
//| Ищем ближайшие фракталы на 60 минутном таймфрэйме
//+-----------------------------------------------------------------------------------------------------------+
  double fractal_240min_hi, fractal_240min_low; 
  int f_240min_hi =0;
  while(fractal_240min_hi == 0)
  {
    fractal_240min_hi = iFractals(NULL, 240, 1, f_240min_hi);
    f_240min_hi++;
  }

  int f_240min_low =0;
  while(fractal_240min_low == 0)
  {
    fractal_240min_low = iFractals(NULL, 240, 2, f_240min_low);
    f_240min_low++;
  }
//+-----------------------------------------------------------------------------------------------------------+
//| Определяем условие вычисления размера спреда 
//| если не установлен в ручную (spred_ramer == 0) то вычисляем исходя из рыночных условий
//+-----------------------------------------------------------------------------------------------------------+
  if (spred_razmer == 0)
  {
    spread = NormalizeDouble(MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits); 
  }
  else
  {
    spread = NormalizeDouble(spred_razmer * Point, Digits); 
  }
  double filtr = NormalizeDouble(filtr_razmer * Point, Digits);
//+-----------------------------------------------------------------------------------------------------------+
//+-----------------------------------------------------------------------------------------------------------+
//| Перебираем открытые рыночные ордера и формируем массивы: buy_orders_price [], sell_orders_price []        |
//+-----------------------------------------------------------------------------------------------------------+
  int num_buy_orders_price  = 0;
  int num_sell_orders_price = 0;

  bool est_sellstop = false;
  bool est_buystop  = false;

  for (int ord = 0; ord < OrdersTotal(); ord ++)
  if(OrderSelect(ord, SELECT_BY_POS))
  { // начало перебора открытых ордеров
    if ((OrderType() == 0) && OrderMagicNumber() == MagicNumber)
    { // BUY 
      buy_orders_price [num_buy_orders_price] = OrderOpenPrice();
      num_buy_orders_price++;
    }
    if ((OrderType() == 4) && OrderMagicNumber() == MagicNumber)
    { // BUYSTOP 
      buy_orders_price [num_buy_orders_price] = OrderOpenPrice();
      num_buy_orders_price++;
      est_buystop = true;
    }
    if ((OrderType() == 1) && OrderMagicNumber() == MagicNumber)
    { // SELL
      sell_orders_price [num_sell_orders_price] = OrderOpenPrice();
      num_sell_orders_price++;
    }
    if ((OrderType() == 5) && OrderMagicNumber() == MagicNumber)
    { // SELLSTOP
      sell_orders_price [num_sell_orders_price] = OrderOpenPrice();
      num_sell_orders_price++;
      est_sellstop = true;
    }
  } // конец перебора открытых ордеров
//+-----------------------------------------------------------------------------------------------------------+
  if (num_buy_orders_price !=0)
  {
    ArrayResize(buy_orders_price,  num_buy_orders_price);
    int num_max_level = ArrayMaximum(buy_orders_price,  num_buy_orders_price,  0);
    double level_max_buy  = buy_orders_price[num_max_level];
  }
  if (num_sell_orders_price != 0)
  {
    ArrayResize(sell_orders_price, num_sell_orders_price);
    int num_min_level = ArrayMinimum(sell_orders_price, num_sell_orders_price, 0);
    double level_min_sell = sell_orders_price[num_min_level];
  }
  Comment("\n Максимальный уровень BUY :" + level_max_buy + " из " + ArrayRange(buy_orders_price, 0) +
          "\n Минимальный уровень SELL :" + level_min_sell + " из " + ArrayRange(sell_orders_price, 0));
//+-----------------------------------------------------------------------------------------------------------+
//| выставляем ордера
//+-----------------------------------------------------------------------------------------------------------+
  
  if (candle_begin())
  { // начало выставляем ордера
    double hi_pred_svechi  = NormalizeDouble((iHigh(NULL, 0, 1) + filtr + spread), Digits);
    double low_pred_svechi = NormalizeDouble((iLow (NULL, 0, 1) - filtr), Digits);
    
    if ((NormalizeDouble((iHigh(NULL, 0, 1) + spread), Digits) - level_max_buy > filtr_otstup_no_orders*Point && level_max_buy != 0 )
        || (level_max_buy == 0 && !est_buystop ))
    {
      double order_buy = razmer_order_buy;
      int case_hi = 0;
      if(hi_pred_svechi - fractal_5min_hi > 0)
      {
        case_hi = 1;
      }
      if(hi_pred_svechi - fractal_60min_hi > 0)
      {
        case_hi = 2;
      }
      switch (case_hi)
      {
        case 0 : order_buy = razmer_order_buy;
        break;
        case 1 : order_buy = x5min * razmer_order_buy;
        break;
        case 2 : order_buy = x60min * razmer_order_buy;
        break;
      }
      int res_buystop  = OrderSend(Symbol(), 
                                   OP_BUYSTOP, 
                                   order_buy, 
                                   hi_pred_svechi,  
                                   5, 
                                   0,  
                                   0,  
                                   "B",  
                                   MagicNumber, 
                                   0, 
                                   Green);
    }
    
    if ((level_min_sell - NormalizeDouble(iLow (NULL, 0, 1), Digits) > filtr_otstup_no_orders*Point)
       || (level_min_sell == 0 && !est_sellstop)) 
    {
      double order_sell = razmer_order_sell;
      int case_low = 0;
      if(low_pred_svechi < fractal_5min_low)
      {
        case_low = 1;
      }
      if(hi_pred_svechi < fractal_60min_low)
      {
        case_low = 2;
      }
      switch (case_low)
      {
        case 0 : order_sell = razmer_order_sell;
        break;
        case 1 : order_sell = x5min * razmer_order_sell;
        break;
        case 2 : order_sell = x60min * razmer_order_sell;
        break;
      }
      int res_sellstop = OrderSend(Symbol(), 
                                   OP_SELLSTOP, 
                                   order_sell, 
                                   low_pred_svechi, 
                                   5, 
                                   0, 
                                   0, 
                                   "S", 
                                   MagicNumber, 
                                   0, 
                                   Red);
    }                                   
  } // конец выставляем ордера
//+-----------------------------------------------------------------------------------------------------------+
//| Закрываем ордера при появлении прибыли задааной при запуске советника
//+-----------------------------------------------------------------------------------------------------------+
  if (AccountProfit() >= profit_close)
  {
    close_all = true;
  }
    
  if (close_all)
  { //начало close_all
    Print("Закрываем все ордера. Достигнут уровень прибыли " + profit_close + " USD.");
    for (int ord_close = 0; ord_close < OrdersTotal(); ord_close ++)
    if(OrderSelect(ord_close, SELECT_BY_POS))
    { // начало перебора открытых ордеров
      if ((OrderType() == 0) && OrderMagicNumber() == MagicNumber)
      { // BUY 
        OrderClose(OrderTicket(), OrderLots(), Bid, 5, Green);
      }
      if ((OrderType() == 4) && OrderMagicNumber() == MagicNumber)
      { // BUYSTOP 
        OrderDelete(OrderTicket());
      }
      if ((OrderType() == 1) && OrderMagicNumber() == MagicNumber)
      { // SELL
        OrderClose(OrderTicket(), OrderLots(), Ask, 5, Red);
      }
      if ((OrderType() == 5) && OrderMagicNumber() == MagicNumber)
      { // SELLSTOP
        OrderDelete(OrderTicket());
      }
    } // конец перебора открытых ордеров
  } //конец close_all
  if (OrdersTotal() == 0)
  {
    close_all = false;
  }
//+-----------------------------------------------------------------------------------------------------------+
  return(0);
} // конец процедуры start()
//+-----------------------------------------------------------------------------------------------------------+

//+-----------------------------------------------------------------------------------------------------------+
//| 1. Процедура - Определяем момент наступления новой свечи                                                  |
//+-----------------------------------------------------------------------------------------------------------+

bool candle_begin()
{
  static int  diff_prev = 0;
         bool rc        = false;
         int  diff      = TimeCurrent() - iTime(NULL, NULL, 0);
  if(diff < diff_prev)
  {
    rc = true;
    diff_prev = 0;
    Print("Начало новой свечи");
    Print("Спрэд: ", NormalizeDouble((Ask-Bid)/Point,0));
  }
  else
  {
    diff_prev = diff;
    rc = false;
  }
  return(rc);
}
//+-----------------------------------------------------------------------------------------------------------+
//| Конец                                                                                                     |
//+-----------------------------------------------------------------------------------------------------------+