//------------------------------------------------------------------
#property copyright "mladen"
#property link      "mladenfx@gmail.com"
#property link      "www.forex-station.com"
//------------------------------------------------------------------
#property indicator_separate_window
#property indicator_buffers 12
#property indicator_color1  clrDimGray
#property indicator_color2  clrDimGray
#property indicator_color3  clrDimGray
#property indicator_color4  clrLime
#property indicator_color5  clrLime
#property indicator_color6  clrRed
#property indicator_color7  clrRed
#property indicator_color8   clrDimGray
#property indicator_color9   clrLime
#property indicator_color10  clrLime
#property indicator_color11  clrRed
#property indicator_color12  clrRed
#property indicator_style1  STYLE_DOT
#property indicator_style2  STYLE_DOT
#property indicator_width3  3
#property indicator_width4  3
#property indicator_width5  3
#property indicator_width6  3
#property indicator_width7  3
#property indicator_width8   3
#property indicator_width9   3
#property indicator_width10  3
#property indicator_width11  3
#property indicator_width12  3
#property strict

//
//
//
//
//

enum enPrices
{
   pr_close,      // Close
   pr_open,       // Open
   pr_high,       // High
   pr_low,        // Low
   pr_median,     // Median
   pr_typical,    // Typical
   pr_weighted,   // Weighted
   pr_average,    // Average (high+low+open+close)/4
   pr_medianb,    // Average median body (open+close)/2
   pr_tbiased,    // Trend biased price
   pr_tbiased2,   // Trend biased (extreme) price
   pr_haclose,    // Heiken ashi close
   pr_haopen ,    // Heiken ashi open
   pr_hahigh,     // Heiken ashi high
   pr_halow,      // Heiken ashi low
   pr_hamedian,   // Heiken ashi median
   pr_hatypical,  // Heiken ashi typical
   pr_haweighted, // Heiken ashi weighted
   pr_haaverage,  // Heiken ashi average
   pr_hamedianb,  // Heiken ashi median body
   pr_hatbiased,  // Heiken ashi trend biased price
   pr_hatbiased2  // Heiken ashi trend biased (extreme) price
};
enum enColorOn
{
   chg_onZero,   // Change color on zero cross
   chg_onOuter,  // Change color on levels cross
   chg_onOuter2, // Change color on opposite levels cross
   chg_onSlope   // Change color on slope change
};
extern ENUM_TIMEFRAMES TimeFrame    = PERIOD_CURRENT; // Time frame
extern ENUM_TIMEFRAMES mTimeFrame   = PERIOD_H1;      // Time frame for "higher TF filtering"
input  int             DspPeriod    = 14;             // DSP period
input  enPrices        Price        = pr_hatbiased2;  // DSP price
extern int             SignalPeriod = 9;              // Signal period
input  enColorOn       ColorOn      = chg_onSlope;    // Change color on :
input  bool            DrawHisto    = false;          // Draw histogram?
extern bool            Interpolate  = true;           // Interpolate in multi time frame mode?
input  bool            alertsOn        = false;           // Turn alerts on?
input  bool            alertsOnCurrent = false;           // Alerts on still opened bar?
input  bool            alertsMessage   = true;            // Alerts should display message?
input  bool            alertsSound     = false;           // Alerts should play a sound?
input  bool            alertsNotify    = false;           // Alerts should send a notification?
input  bool            alertsEmail     = false;           // Alerts should send an email?
input  string          soundFile       = "alert2.wav";    // Sound file

double val[],valua[],valub[],valda[],valdb[],levelu[],leveld[],state[],mstate[],vline[],vlineua[],vlineub[],vlineda[],vlinedb[],count[];
string indicatorFileName;
#define _mtfCall(_timeframe,_buff,_y) iCustom(NULL,_timeframe,indicatorFileName,PERIOD_CURRENT,PERIOD_CURRENT,DspPeriod,Price,SignalPeriod,ColorOn,_buff,_y)
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

int OnInit()
{
   int dhisto = (!DrawHisto) ? DRAW_LINE : DRAW_HISTOGRAM;
   int drline = (!DrawHisto) ? DRAW_NONE : DRAW_LINE;
   IndicatorBuffers(15);
      SetIndexBuffer( 0, levelu);
      SetIndexBuffer( 1, leveld);
      SetIndexBuffer( 2, val);    SetIndexStyle(2,dhisto);
      SetIndexBuffer( 3, valua);  SetIndexStyle(3,dhisto);
      SetIndexBuffer( 4, valub);  SetIndexStyle(4,dhisto);
      SetIndexBuffer( 5, valda);  SetIndexStyle(5,dhisto);
      SetIndexBuffer( 6, valdb);  SetIndexStyle(6,dhisto);
      SetIndexBuffer( 7, vline);  SetIndexStyle(7,drline);
      SetIndexBuffer( 8, vlineua);  SetIndexStyle( 8,drline);      
      SetIndexBuffer( 9, vlineub);  SetIndexStyle( 9,drline);      
      SetIndexBuffer(10, vlineda);  SetIndexStyle(10,drline);      
      SetIndexBuffer(11, vlinedb);  SetIndexStyle(11,drline);      
      SetIndexBuffer(12, state);
      SetIndexBuffer(13, mstate); 
      SetIndexBuffer(14, count); 
            indicatorFileName = WindowExpertName();
            TimeFrame         = MathMax(TimeFrame,_Period);
           mTimeFrame         = MathMax(mTimeFrame,_Period); 
   IndicatorShortName(timeFrameToString(TimeFrame)+"/"+timeFrameToString(mTimeFrame)+" DSP oscillator ("+(string)DspPeriod+")");
   return(0);
}
void OnDeinit(const int reason) { }
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int      &spread[])
{
   int counted_bars = prev_calculated;
      if(counted_bars < 0) return(-1);
      if(counted_bars > 0) counted_bars--;
         int limit=MathMin(rates_total-counted_bars,rates_total-1); count[0] = limit;
         
         if (mTimeFrame!=_Period)
         {
 
            for (int i=limit;i>=0 && !_StopFlag; i--)
            {
               int y = iBarShift(NULL,mTimeFrame,time[i]);
               mstate[i] = _mtfCall(mTimeFrame,12,y);
            }

         } 
         
         
         if (TimeFrame!=_Period)
         {
            limit = (int)MathMax(limit,MathMin(Bars-1,_mtfCall(TimeFrame,14,0)*TimeFrame/_Period));
            if (state[limit]== 1) { CleanPoint(limit,valua,valub); CleanPoint(limit,vlineua,vlineub); }
            if (state[limit]==-1) { CleanPoint(limit,valda,valdb); CleanPoint(limit,vlineda,vlinedb); }
            for(int i=limit; i>=0; i--)
            {
               int y = iBarShift(NULL,TimeFrame,Time[i]);
               levelu[i] = _mtfCall(TimeFrame,0,y);
               leveld[i] = _mtfCall(TimeFrame,1,y);
               val[i]    = _mtfCall(TimeFrame,2,y);
               vline[i]  =  val[i];
               state[i]  = _mtfCall(TimeFrame,12,y);
               valda[i]  = EMPTY_VALUE;
               valdb[i]  = EMPTY_VALUE;
               valua[i]  = EMPTY_VALUE;
               valub[i]  = EMPTY_VALUE;
               vlineua[i] = EMPTY_VALUE;
               vlineub[i] = EMPTY_VALUE;
               vlineda[i] = EMPTY_VALUE;
               vlinedb[i] = EMPTY_VALUE;               
                  if (!Interpolate || (i>0 && y==iBarShift(NULL,TimeFrame,Time[i-1]))) continue;
                  
                  //
                  //
                  //
                  //
                  //
                  
                  #define _interpolate(buff) buff[i+k] = buff[i]+(buff[i+n]-buff[i])*k/n
                  int n,k; datetime ttime = iTime(NULL,TimeFrame,y);
                     for(n = 1; (i+n)<rates_total && time[i+n] >= ttime; n++) continue;	
                     for(k = 1; k<n && (i+n)<rates_total && (i+k)<rates_total; k++)
                     {
                         _interpolate(leveld);
                         _interpolate(levelu);
                         _interpolate(val);
                         _interpolate(vline);
                     }                        
            }
            for(int i=limit; i>=0; i--)
            {
                if (mTimeFrame!=_Period)
                {
                  if (state[i] ==  1 && mstate[i] == 1) { PlotPoint(i,valua,valub,val); PlotPoint(i,vlineua,vlineub,vline); }
                  if (state[i] == -1 && mstate[i] ==-1) { PlotPoint(i,valda,valdb,val); PlotPoint(i,vlineda,vlinedb,vline); }               
                }
                else
                {
                  if (state[i] ==  1) { PlotPoint(i,valua,valub,val); PlotPoint(i,vlineua,vlineub,vline); }
                  if (state[i] == -1) { PlotPoint(i,valda,valdb,val); PlotPoint(i,vlineda,vlinedb,vline); } 
                }

            }                  
            return(rates_total);
         }               
         
   //
   //
   //
   //
   //

   double alphas = 2.0/(1.0+SignalPeriod);
   double alpham = 2.0/(1.0+DspPeriod);
   if (state[limit]== 1) { CleanPoint(limit,valua,valub); CleanPoint(limit,vlineua,vlineub); }
   if (state[limit]==-1) { CleanPoint(limit,valda,valdb); CleanPoint(limit,vlineda,vlinedb); }
   for(int i=limit; i>=0 && !_StopFlag; i--)
   {
      double price = getPrice(Price,open,close,high,low,i,rates_total);
         val[i]    = iEma(price,alpham,i,rates_total,0)-iEma(price,alpham/2.0,i,rates_total,1);
         vline[i]  = val[i];
         levelu[i] = (i<Bars-1) ? (val[i]>0) ? levelu[i+1]+alphas*(val[i]-levelu[i+1]) : levelu[i+1] : 0;
         leveld[i] = (i<Bars-1) ? (val[i]<0) ? leveld[i+1]+alphas*(val[i]-leveld[i+1]) : leveld[i+1] : 0;
                switch(ColorOn)
                {
                  case chg_onOuter  : state[i] = (val[i]>levelu[i]) ? 1 : (val[i]<leveld[i]) ? -1 : 0;                                 break;
                  case chg_onOuter2 : state[i] = (val[i]>levelu[i]) ? 1 : (val[i]<leveld[i]) ? -1 : (i<rates_total-1) ? state[i+1]: 0; break;
                  case chg_onZero   : state[i] = (val[i]>0)         ? 1 : (val[i]<0)         ? -1 : 0;                                 break;
                  default :           state[i] = (i<rates_total-1) ? (val[i]>val[i+1]) ? 1 : (val[i]<val[i+1]) ? -1 : state[i+1] : 0;
                }
                valda[i] = EMPTY_VALUE;
                valdb[i] = EMPTY_VALUE;
                valua[i] = EMPTY_VALUE;
                valub[i] = EMPTY_VALUE;
                vlineua[i] = EMPTY_VALUE;
                vlineub[i] = EMPTY_VALUE;
                vlineda[i] = EMPTY_VALUE;
                vlinedb[i] = EMPTY_VALUE;
                
                if (mTimeFrame!=_Period)
                {
                  if (state[i] ==  1 && mstate[i] == 1) { PlotPoint(i,valua,valub,val); PlotPoint(i,vlineua,vlineub,vline); }
                  if (state[i] == -1 && mstate[i] ==-1) { PlotPoint(i,valda,valdb,val); PlotPoint(i,vlineda,vlinedb,vline); }               
                }
                else
                {
                  if (state[i] ==  1) { PlotPoint(i,valua,valub,val); PlotPoint(i,vlineua,vlineub,vline); }
                  if (state[i] == -1) { PlotPoint(i,valda,valdb,val); PlotPoint(i,vlineda,vlinedb,vline); } 
                }
                
                if (alertsOn)
   {
      int whichBar = 1; if (alertsOnCurrent) whichBar = 0; 
      if (state[whichBar] != state[whichBar+1])
      {
          if (state[whichBar] == 1) doAlert(" up");
          if (state[whichBar] ==-1) doAlert(" down");       
       }         
    }     
         
   }
   return(rates_total);
}

//------------------------------------------------------------------
//                                                                  
//------------------------------------------------------------------
//
//
//
//
//

double workEma[][2];
double iEma(double price, double alpha, int r, int _bars, int instanceNo=0)
{
   if (ArrayRange(workEma,0)!= _bars) ArrayResize(workEma,_bars); r=_bars-r-1;

   workEma[r][instanceNo] = price;
   if (r>0)
          workEma[r][instanceNo] = workEma[r-1][instanceNo]+alpha*(price-workEma[r-1][instanceNo]);
   return(workEma[r][instanceNo]);
}


//-------------------------------------------------------------------
//                                                                  
//-------------------------------------------------------------------
//
//
//
//
//

void CleanPoint(int i,double& first[],double& second[])
{
   if (i>=Bars-3) return;
   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
        second[i+1] = EMPTY_VALUE;
   else
      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
          first[i+1] = EMPTY_VALUE;
}

void PlotPoint(int i,double& first[],double& second[],double& from[])
{
   if (i>=Bars-2) return;
   if (first[i+1] == EMPTY_VALUE)
      if (first[i+2] == EMPTY_VALUE) 
            { first[i]  = from[i];  first[i+1]  = from[i+1]; second[i] = EMPTY_VALUE; }
      else  { second[i] =  from[i]; second[i+1] = from[i+1]; first[i]  = EMPTY_VALUE; }
   else     { first[i]  = from[i];                           second[i] = EMPTY_VALUE; }
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//

#define _priceInstances     1
#define _priceInstancesSize 4
double workHa[][_priceInstances*_priceInstancesSize];
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int bars, int instanceNo=0)
{
  if (tprice>=pr_haclose)
   {
      if (ArrayRange(workHa,0)!= bars) ArrayResize(workHa,bars); instanceNo*=_priceInstancesSize;
         int r = bars-i-1;
         
         //
         //
         //
         //
         //
         
         double haOpen;
         if (r>0)
                haOpen  = (workHa[r-1][instanceNo+2] + workHa[r-1][instanceNo+3])/2.0;
         else   haOpen  = (open[i]+close[i])/2;
         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));
         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));

         if(haOpen  <haClose) { workHa[r][instanceNo+0] = haLow;  workHa[r][instanceNo+1] = haHigh; } 
         else                 { workHa[r][instanceNo+0] = haHigh; workHa[r][instanceNo+1] = haLow;  } 
                                workHa[r][instanceNo+2] = haOpen;
                                workHa[r][instanceNo+3] = haClose;
         //
         //
         //
         //
         //
         
         switch (tprice)
         {
            case pr_haclose:     return(haClose);
            case pr_haopen:      return(haOpen);
            case pr_hahigh:      return(haHigh);
            case pr_halow:       return(haLow);
            case pr_hamedian:    return((haHigh+haLow)/2.0);
            case pr_hamedianb:   return((haOpen+haClose)/2.0);
            case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);
            case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);
            case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);
            case pr_hatbiased:
               if (haClose>haOpen)
                     return((haHigh+haClose)/2.0);
               else  return((haLow+haClose)/2.0);        
            case pr_hatbiased2:
               if (haClose>haOpen)  return(haHigh);
               if (haClose<haOpen)  return(haLow);
                                    return(haClose);        
         }
   }
   
   //
   //
   //
   //
   //
   
   switch (tprice)
   {
      case pr_close:     return(close[i]);
      case pr_open:      return(open[i]);
      case pr_high:      return(high[i]);
      case pr_low:       return(low[i]);
      case pr_median:    return((high[i]+low[i])/2.0);
      case pr_medianb:   return((open[i]+close[i])/2.0);
      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);
      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);
      case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);
      case pr_tbiased:   
               if (close[i]>open[i])
                     return((high[i]+close[i])/2.0);
               else  return((low[i]+close[i])/2.0);        
      case pr_tbiased2:   
               if (close[i]>open[i]) return(high[i]);
               if (close[i]<open[i]) return(low[i]);
                                     return(close[i]);        
   }
   return(0);
}   

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//

void doAlert(string doWhat)
{
   static string   previousAlert="nothing";
   static datetime previousTime;
   string message;
   
      if (previousAlert != doWhat || previousTime != Time[0]) {
          previousAlert  = doWhat;
          previousTime   = Time[0];

          //
          //
          //
          //
          //

          message =  StringConcatenate(_Symbol," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," Detrended Synthetic Price(bars) ",doWhat);
             if (alertsMessage) Alert(message);
             if (alertsNotify)  SendNotification(message);
             if (alertsEmail)   SendMail(_Symbol+" Detrended Synthetic Price(bars) ",message);
             if (alertsSound)   PlaySound(soundFile);
      }
}


string sTfTable[] = {"M1","M5","M15","M30","H1","H4","D1","W1","MN"};
int    iTfTable[] = {1,5,15,30,60,240,1440,10080,43200};

string timeFrameToString(int tf)
{
   for (int i=ArraySize(iTfTable)-1; i>=0; i--) 
         if (tf==iTfTable[i]) return(sTfTable[i]);
                              return("");
}