#include <stdlib.mqh>

/******************************************************************************/
#property indicator_chart_window

#property indicator_buffers 8

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/

/* Здесь можно исправить значения, эти значения используются по умолчанию при подключении индикатора */

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/

/* Цвета набора средних (встав курсором на имени цвета, нажать F1 и увидеть имена остальных цветов) */
#property indicator_color1 OrangeRed
#property indicator_color2 Orange
#property indicator_color3 Yellow
#property indicator_color4 DodgerBlue
#property indicator_color5 Aqua
#property indicator_color6 Magenta
#property indicator_color7 Gray
#property indicator_color8 White

/* Стили каждой средней из набора средних (встав курсором на имени стиля, нажать F1 и увидеть названия остальных стилей - вторая табличка) */
/* Стили работают только если толщина линии равна 1 */
#property indicator_style1 STYLE_SOLID
#property indicator_style2 STYLE_SOLID
#property indicator_style3 STYLE_SOLID
#property indicator_style4 STYLE_SOLID
#property indicator_style5 STYLE_SOLID
#property indicator_style6 STYLE_SOLID
#property indicator_style7 STYLE_SOLID
#property indicator_style8 STYLE_SOLID

/* Толщина каждой средней из набора средних (от 1 до 8, но стили работают только при толщине 1) */
#property indicator_width1 1
#property indicator_width2 1
#property indicator_width3 1
#property indicator_width4 1
#property indicator_width5 1
#property indicator_width6 1
#property indicator_width7 1
#property indicator_width8 1

/******************************************************************************
  Indicator parameters
*/

/* Префикс индикатора */
extern string Prefix = "";

/* Общий рубильник отображения правильности веера, позволяет отрубить разом отображение набора всех периодов */
extern bool DisplayFanStatus = true;

/* Общий рубильник отображения средних, позволяет отрубить разом отображение набора средних */
extern bool DisplayFan = true;

/* Количество баров, для которых рисуется веер; если меньше 1 или больше, чем всего баров, - рисуется для всех баров */
extern int DisplayBars = 0;

/* Установить в true при работе в визуализаторе тестера, чтобы статусы обновлялись при каждом тике */
extern bool DisplayEveryTick = false;

/* Значения периодов набора timeframe'ов в порядке следования слева направо (возможны повторения, 0-вые и неправильные значения включены в набор не будут) */
extern int Timeframe1 = PERIOD_M1;
extern int Timeframe2 = PERIOD_M5;
extern int Timeframe3 = PERIOD_M15;
extern int Timeframe4 = PERIOD_H1;
extern int Timeframe5 = PERIOD_H4;
extern int Timeframe6 = PERIOD_D1;
extern int Timeframe7 = 0;
extern int Timeframe8 = 0;
extern int Timeframe9 = 0;

/* Дата и время, для которого индицируется правильность веера */
extern datetime TrackingTime = 0;

/* Рисовать ли вертикальную линию через отслеживаемый бар */
extern bool Tracking = false;

/* Сдвигаем ли точку слежения с образовнием следущего бара */
extern bool Sliding = true;

/* Имя файла звука, воспроизводимого при сдвиге точки слежения */
extern string SlidingSound = "";

/* Значения периодов набора средних, составляющих веер, правильность которого отслеживается (0-вые и неправильные значения включены в набор не будут) */
extern int MA1 = 233;
extern int MA2 = 55;
extern int MA3 = 21;
extern int MA4 = 5;
extern int MA5 = 0;
extern int MA6 = 0;
extern int MA7 = 0;
extern int MA8 = 0;

/* Индивидуальный рубильник отображения на каждую среднюю */
extern bool DisplayMA1 = true;
extern bool DisplayMA2 = true;
extern bool DisplayMA3 = true;
extern bool DisplayMA4 = true;
extern bool DisplayMA5 = true;
extern bool DisplayMA6 = true;
extern bool DisplayMA7 = true;
extern bool DisplayMA8 = true;

/* Индивидуальное задание типа каждой средней */
extern int TypeOfMA1 = MODE_EMA;
extern int TypeOfMA2 = MODE_EMA;
extern int TypeOfMA3 = MODE_EMA;
extern int TypeOfMA4 = MODE_EMA;
extern int TypeOfMA5 = MODE_EMA;
extern int TypeOfMA6 = MODE_EMA;
extern int TypeOfMA7 = MODE_EMA;
extern int TypeOfMA8 = MODE_EMA;

/* Индивидуальное задание типа цены для каждой средней */
extern int PriceOfMA1 = PRICE_CLOSE;
extern int PriceOfMA2 = PRICE_CLOSE;
extern int PriceOfMA3 = PRICE_CLOSE;
extern int PriceOfMA4 = PRICE_CLOSE;
extern int PriceOfMA5 = PRICE_CLOSE;
extern int PriceOfMA6 = PRICE_CLOSE;
extern int PriceOfMA7 = PRICE_CLOSE;
extern int PriceOfMA8 = PRICE_CLOSE;

/* Индивидуальное задание сдвига по оси времени в барах для каждой средней */
extern int ShiftOfMA1 = 0;
extern int ShiftOfMA2 = 0;
extern int ShiftOfMA3 = 0;
extern int ShiftOfMA4 = 0;
extern int ShiftOfMA5 = 0;
extern int ShiftOfMA6 = 0;
extern int ShiftOfMA7 = 0;
extern int ShiftOfMA8 = 0;

/* Имя фонта символов */
extern string FontName = "Wingdings";

/* Размер символов */
extern int FontSize = 12;

/* Символы нарисованного и стёртого указателя положения цены относительно веера */
extern int PriceOnSymbol = 108; // Circle
extern int PriceOffSymbol = 32; // Space

/* Цвета нарисованного указателя положения цены относительно веера */
extern color PriceColor = LimeGreen;

/* Символы указателя правильности веера */
extern int FanWrongSymbol = 117; // Diamond
extern int FanUpSymbol = 233; // Up Arrow
extern int FanDownSymbol = 234; // Down Arrow

/* Цвета указателя правильности веера */
extern color FanWrongColor = DarkGray;
extern color FanUpColor = DodgerBlue;
extern color FanDownColor = OrangeRed;

/* Смещение влево (X) и вправо (Y) от правого верхнего угла */
extern int X = 0;
extern int Y = 0;

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/

/******************************************************************************
  Tracking vertical line label and color
*/
#define TRACKING_NAME "Бар, отслеживаемый индикатором FanSimple"
#define TRACKING_COLOR DarkGray

/******************************************************************************/
string RowName[3] = { "Цена выше веера",
                      "Статус веера",
                      "Цена ниже веера" };

/******************************************************************************/
/******************************************************************************/
/******************************************************************************

/*** А вот сюда лазить уже не следует **** А вот сюда лазить уже не следует ***/
/*** А вот сюда лазить уже не следует **** А вот сюда лазить уже не следует ***/
/*** А вот сюда лазить уже не следует **** А вот сюда лазить уже не следует ***/

/******************************************************************************/
/******************************************************************************/
/******************************************************************************
  Type of rendering codes
*/
#define is_down    0
#define is_none    1
#define is_up      2

/******************************************************************************/
int Timeframe[9];
string TimeframeNames[9];
int TimeframeInUse = 0;

/******************************************************************************/
int MAs[8];
int TypeOfMAs[8];
int PriceOfMAs[8];
int ShiftOfMAs[8];

int Xlat[8];
int MAsInUse = 0;

/******************************************************************************/
double MA1Buf[], MA2Buf[], MA3Buf[], MA4Buf[], MA5Buf[], MA6Buf[], MA7Buf[], MA8Buf[];

/******************************************************************************/
string LabelName(int i, int j) { return(Prefix + RowName[j] + "(" + (i + 1) + "): " + TimeframeNames[i]); }

/******************************************************************************/
int symcolor[3][2];
int syms[3][2];

/******************************************************************************/
void UpdateFanStatus(int i, int how)
{
  string s = " ";

  ObjectSetText(LabelName(i, 1), StringSetChar(s, 0, symcolor[how][0]), FontSize, FontName, symcolor[how][1]);
}

/******************************************************************************/
void UpdatePriceStatus(int i, int how)
{
  string s = " ";

  ObjectSetText(LabelName(i, 0), StringSetChar(s, 0, syms[how][0]), FontSize, FontName, PriceColor);
  ObjectSetText(LabelName(i, 2), StringSetChar(s, 0, syms[how][1]), FontSize, FontName, PriceColor);
}

/******************************************************************************/
void InitTimeframe(int &P[], int PV)
{
  if(PV != 0)
  {
    switch(PV)
    {
    case PERIOD_M1:  TimeframeNames[TimeframeInUse] = "M1";  break;
    case PERIOD_M5:  TimeframeNames[TimeframeInUse] = "M5";  break;
    case PERIOD_M15: TimeframeNames[TimeframeInUse] = "M15"; break;
    case PERIOD_M30: TimeframeNames[TimeframeInUse] = "M30"; break;
    case PERIOD_H1:  TimeframeNames[TimeframeInUse] = "H1";  break;
    case PERIOD_H4:  TimeframeNames[TimeframeInUse] = "H4";  break;
    case PERIOD_D1:  TimeframeNames[TimeframeInUse] = "D1";  break;
    case PERIOD_W1:  TimeframeNames[TimeframeInUse] = "W1";  break;
    case PERIOD_MN1: TimeframeNames[TimeframeInUse] = "MN1"; break;
    default: return;
    }

    P[TimeframeInUse] = PV; TimeframeInUse++;
  }
}

/******************************************************************************/
bool __CheckMA(int MA, int TypeOfMA, int PriceOfMA)
{
  return(MA > 0 &&
        (TypeOfMA == MODE_SMA || TypeOfMA == MODE_EMA || TypeOfMA == MODE_SMMA || TypeOfMA == MODE_LWMA) &&
        (PriceOfMA == PRICE_CLOSE || PriceOfMA == PRICE_OPEN || PriceOfMA == PRICE_HIGH || PriceOfMA == PRICE_LOW || PriceOfMA == PRICE_MEDIAN || PriceOfMA == PRICE_TYPICAL || PriceOfMA == PRICE_WEIGHTED));
}

/******************************************************************************/
bool CheckMA(int MA)
{
  switch(MA)
  {
  case 1: return(__CheckMA(MA1, TypeOfMA1, PriceOfMA1)); break;
  case 2: return(__CheckMA(MA2, TypeOfMA2, PriceOfMA2)); break;
  case 3: return(__CheckMA(MA3, TypeOfMA3, PriceOfMA3)); break;
  case 4: return(__CheckMA(MA4, TypeOfMA4, PriceOfMA4)); break;
  case 5: return(__CheckMA(MA5, TypeOfMA5, PriceOfMA5)); break;
  case 6: return(__CheckMA(MA6, TypeOfMA6, PriceOfMA6)); break;
  case 7: return(__CheckMA(MA7, TypeOfMA7, PriceOfMA7)); break;
  case 8: return(__CheckMA(MA8, TypeOfMA8, PriceOfMA8)); break;
  }

  return(false);
}

/******************************************************************************/
void __InitMAs(int MA, int TypeOfMA, int PriceOfMA, int ShiftOfMA)
{
  if(__CheckMA(MA, TypeOfMA, PriceOfMA))
  {
    MAs[MAsInUse] = MA;
    TypeOfMAs[MAsInUse] = TypeOfMA;
    PriceOfMAs[MAsInUse] = PriceOfMA;
    ShiftOfMAs[MAsInUse] = ShiftOfMA;
    MAsInUse++;
  }
}

/******************************************************************************/
void InitMAs(int MA)
{
  switch(MA)
  {
  case 1: __InitMAs(MA1, TypeOfMA1, PriceOfMA1, ShiftOfMA1); break;
  case 2: __InitMAs(MA2, TypeOfMA2, PriceOfMA2, ShiftOfMA2); break;
  case 3: __InitMAs(MA3, TypeOfMA3, PriceOfMA3, ShiftOfMA3); break;
  case 4: __InitMAs(MA4, TypeOfMA4, PriceOfMA4, ShiftOfMA4); break;
  case 5: __InitMAs(MA5, TypeOfMA5, PriceOfMA5, ShiftOfMA5); break;
  case 6: __InitMAs(MA6, TypeOfMA6, PriceOfMA6, ShiftOfMA6); break;
  case 7: __InitMAs(MA7, TypeOfMA7, PriceOfMA7, ShiftOfMA7); break;
  case 8: __InitMAs(MA8, TypeOfMA8, PriceOfMA8, ShiftOfMA8); break;
  }
}

/******************************************************************************/
int init()
{
  int i, j;

  if(DisplayFanStatus)
  {
    syms[0][0] = PriceOffSymbol; syms[0][1] = PriceOnSymbol;
    syms[1][0] = PriceOffSymbol; syms[1][1] = PriceOffSymbol;
    syms[2][0] = PriceOnSymbol; syms[2][1] = PriceOffSymbol;

    symcolor[0][0] = FanDownSymbol; symcolor[0][1] = FanDownColor;
    symcolor[1][0] = FanWrongSymbol; symcolor[1][1] = FanWrongColor;
    symcolor[2][0] = FanUpSymbol; symcolor[2][1] = FanUpColor;

    InitTimeframe(Timeframe, Timeframe1); InitTimeframe(Timeframe, Timeframe2);
    InitTimeframe(Timeframe, Timeframe3); InitTimeframe(Timeframe, Timeframe4);
    InitTimeframe(Timeframe, Timeframe5); InitTimeframe(Timeframe, Timeframe6);
    InitTimeframe(Timeframe, Timeframe7); InitTimeframe(Timeframe, Timeframe8);
    InitTimeframe(Timeframe, Timeframe9);

    InitMAs(1); InitMAs(2); InitMAs(3); InitMAs(4);
    InitMAs(5); InitMAs(6); InitMAs(7); InitMAs(8);

    for(i = 0; i < MAsInUse; i++) Xlat[i] = i;

    for(i = 0; i < MAsInUse - 1; i++)
      for(j = i + 1; j < MAsInUse; j++)
        if(MAs[Xlat[i]] > MAs[Xlat[j]]) { int k = Xlat[j]; Xlat[j] = Xlat[i]; Xlat[i] = k; }

    for(i = 0; i < TimeframeInUse; i++)
      for(j = 0; j < 3; j++)
      {
        string s = LabelName(i, j);

        ObjectCreate(s, OBJ_LABEL, 0, 0, 0);   
        ObjectSet(s, OBJPROP_XDISTANCE, (TimeframeInUse - i - 1) * 13 * FontSize / 10 + 2 * FontSize / 10 + X);
        ObjectSet(s, OBJPROP_YDISTANCE, j * 16 * FontSize / 10 + 3 * FontSize / 10 + Y);
        ObjectSet(s, OBJPROP_BACK, true);
        ObjectSet(s, OBJPROP_CORNER, 1);
        ObjectSetText(s, " ", FontSize, FontName, Black);
      }

    if(Tracking)
    {
      ObjectCreate(Prefix + TRACKING_NAME, OBJ_VLINE, 0, TrackingTime, 0);
      ObjectSet(Prefix + TRACKING_NAME, OBJPROP_COLOR, TRACKING_COLOR);
    }
  }

  if(DisplayFan)
  {
    string IndicatorName = Prefix + "FanSimple(";

    if(DisplayMA1 && CheckMA(1)) IndicatorName = IndicatorName + MA1;
    if(DisplayMA2 && CheckMA(2)) IndicatorName = IndicatorName + ", " + MA2;
    if(DisplayMA3 && CheckMA(3)) IndicatorName = IndicatorName + ", " + MA3;
    if(DisplayMA4 && CheckMA(4)) IndicatorName = IndicatorName + ", " + MA4;
    if(DisplayMA5 && CheckMA(5)) IndicatorName = IndicatorName + ", " + MA5;
    if(DisplayMA6 && CheckMA(6)) IndicatorName = IndicatorName + ", " + MA6;
    if(DisplayMA7 && CheckMA(7)) IndicatorName = IndicatorName + ", " + MA7;
    if(DisplayMA8 && CheckMA(8)) IndicatorName = IndicatorName + ", " + MA8;

    IndicatorShortName(IndicatorName + ")");

    IndicatorBuffers(8);

    SetIndexBuffer(0, MA1Buf); SetIndexBuffer(1, MA2Buf); SetIndexBuffer(2, MA3Buf); SetIndexBuffer(3, MA4Buf);
    SetIndexBuffer(4, MA5Buf); SetIndexBuffer(5, MA6Buf); SetIndexBuffer(6, MA7Buf); SetIndexBuffer(7, MA8Buf);

    SetIndexLabel(0, Prefix + "Веер, " + MA1 + "-я средняя");
    SetIndexLabel(1, Prefix + "Веер, " + MA2 + "-я средняя");
    SetIndexLabel(2, Prefix + "Веер, " + MA3 + "-я средняя");
    SetIndexLabel(3, Prefix + "Веер, " + MA4 + "-я средняя");
    SetIndexLabel(4, Prefix + "Веер, " + MA5 + "-я средняя");
    SetIndexLabel(5, Prefix + "Веер, " + MA6 + "-я средняя");
    SetIndexLabel(6, Prefix + "Веер, " + MA7 + "-я средняя");
    SetIndexLabel(7, Prefix + "Веер, " + MA8 + "-я средняя");

    for(i = 0; i < 7; i++)
    {
      SetIndexStyle(i, DRAW_LINE);
      SetIndexEmptyValue(i, 0);
    }

    SetIndexShift(0, ShiftOfMA1);
    SetIndexShift(1, ShiftOfMA2);
    SetIndexShift(2, ShiftOfMA3);
    SetIndexShift(3, ShiftOfMA4);
    SetIndexShift(4, ShiftOfMA5);
    SetIndexShift(5, ShiftOfMA6);
    SetIndexShift(6, ShiftOfMA7);
    SetIndexShift(7, ShiftOfMA8);

    ArraySetAsSeries(MA1Buf, true); ArraySetAsSeries(MA2Buf, true); ArraySetAsSeries(MA3Buf, true); ArraySetAsSeries(MA4Buf, true);
    ArraySetAsSeries(MA5Buf, true); ArraySetAsSeries(MA6Buf, true); ArraySetAsSeries(MA7Buf, true); ArraySetAsSeries(MA8Buf, true);

    for(i = Bars - 1; i >= 0; i--)
    {
      MA1Buf[i] = 0; MA2Buf[i] = 0; MA3Buf[i] = 0; MA4Buf[i] = 0; MA5Buf[i] = 0; MA6Buf[i] = 0; MA7Buf[i] = 0; MA8Buf[i] = 0;
    }
  }

  return(0);
}

/******************************************************************************/
int deinit()
{
  for(int i = 0; i < TimeframeInUse; i++)
    for(int j = 0; j < 3; j++)
      ObjectDelete(LabelName(i, j));

  if(Tracking)
    ObjectDelete(Prefix + TRACKING_NAME);

  return(0);
}

/******************************************************************************/
int start()
{
  int i;
  datetime NewTrackingTime = TrackingTime;

  static datetime time = 0;

  if(time == 0)
  {
    if(TrackingTime == 0)
      TrackingTime = Time[0];

    if(Tracking)
      ObjectSet(Prefix + TRACKING_NAME, OBJPROP_TIME1, TrackingTime);
    else
      NewTrackingTime = TrackingTime;
  }

  if(Tracking)
    NewTrackingTime = ObjectGet(Prefix + TRACKING_NAME, OBJPROP_TIME1);

  /* Работаем в визуализаторе тестера или пользователь сдвинул точку слежения или точка слежения - последний бар или появился новый бар */
  if(DisplayEveryTick || NewTrackingTime != TrackingTime || (CurTime() - TrackingTime) / 60  < Period() || time != Time[0])
  {
    if(DisplayFanStatus)
      for(i = 0; i < TimeframeInUse; i++)
      {
        bool Up = true, Down = true;
        bool PriceUp = true, PriceDown = true;

        int LocalShift = iBarShift(Symbol(), Timeframe[i], NewTrackingTime + (Period() - 1) * 60);

        double PrevMA = 0;

        for(int j = 0; j < MAsInUse; j++)
        {
          double MA = iMA(NULL, Timeframe[i], MAs[Xlat[j]], ShiftOfMAs[Xlat[j]], TypeOfMAs[Xlat[j]], PriceOfMAs[Xlat[j]], LocalShift);

          if(j > 0) { if(Up && PrevMA < MA) Up = false; if(Down && PrevMA > MA) Down = false; }

          if(PriceUp && MA > iClose(Symbol(), Timeframe[i], LocalShift)) PriceUp = false;
          if(PriceDown && MA < iClose(Symbol(), Timeframe[i], LocalShift)) PriceDown = false;

          PrevMA = MA;
        }

        if(Up && !Down) UpdateFanStatus(i, is_up); else if(!Up && Down) UpdateFanStatus(i, is_down); else UpdateFanStatus(i, is_none);
        if(PriceUp && !PriceDown) UpdatePriceStatus(i, is_up); else if(!PriceUp && PriceDown) UpdatePriceStatus(i, is_down); else UpdatePriceStatus(i, is_none);
      }

    if(DisplayFan)
    {
      i = Bars - IndicatorCounted() - 1;

      if(i >= Bars)
        i = Bars - 1;

      if(i > DisplayBars - 1 && DisplayBars > 0)
        i = DisplayBars - 1;

      for(; i >= 0; i--)
      {
        if(DisplayMA1 && CheckMA(1)) MA1Buf[i] = iMA(NULL, 0, MA1, 0, TypeOfMA1, PriceOfMA1, i);
        if(DisplayMA2 && CheckMA(2)) MA2Buf[i] = iMA(NULL, 0, MA2, 0, TypeOfMA2, PriceOfMA2, i);
        if(DisplayMA3 && CheckMA(3)) MA3Buf[i] = iMA(NULL, 0, MA3, 0, TypeOfMA3, PriceOfMA3, i);
        if(DisplayMA4 && CheckMA(4)) MA4Buf[i] = iMA(NULL, 0, MA4, 0, TypeOfMA4, PriceOfMA4, i);
        if(DisplayMA5 && CheckMA(5)) MA5Buf[i] = iMA(NULL, 0, MA5, 0, TypeOfMA5, PriceOfMA5, i);
        if(DisplayMA6 && CheckMA(6)) MA6Buf[i] = iMA(NULL, 0, MA6, 0, TypeOfMA6, PriceOfMA6, i);
        if(DisplayMA7 && CheckMA(7)) MA7Buf[i] = iMA(NULL, 0, MA7, 0, TypeOfMA7, PriceOfMA7, i);
        if(DisplayMA8 && CheckMA(8)) MA8Buf[i] = iMA(NULL, 0, MA8, 0, TypeOfMA8, PriceOfMA8, i);
      }
    }

    if(time != Time[0])
    {
      if(Sliding && time != 0)
        NewTrackingTime += Time[0] - time;

      time = Time[0];
    }

    if(Tracking && NewTrackingTime != TrackingTime)
      ObjectSet(Prefix + TRACKING_NAME, OBJPROP_TIME1, NewTrackingTime);

    if(StringLen(SlidingSound) != 0 && NewTrackingTime != TrackingTime)
      PlaySound(SlidingSound);

    TrackingTime = NewTrackingTime;
  }

  return(0);
}