//+------------------------------------------------------------------+
//|                                               110201_MA_MACD.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"

#include <Trade\Trade.mqh>

input int   MA1Period         =  21; //MA short Period
input int   MA2Period         =  55; //MA long Period
input int   MACDFastEMA       =  12; //MACD Fast EMA
input int   MACDSlowEMA       =  26; //MACD Slow EMA
input int   MACDSignalPeriod  =  9;  //MACD Signal Period
input int   RSIPeriod         =  12; //RSI Period
input int   ADXPeriod         =  14; //ADX Period
input double ADXMinimum       =  22.0; //ADX Minimum Value
input double MaximumRisk      =  0.02; // Maximum Trade Risk
input double sl_pips          =  30.0; //Pips to Stoploss
input int   ATRPeriod         =  14; //ATR averaging Period

int handle_MA1;
int handle_MA2;
int handle_MACD;
int handle_RSI;
int handle_DMI;
int handle_ATR;
int BAL;
MqlDateTime dt_struct;
int current_hour;
int current_day;
double conviction[5];
bool tradeActive;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
   TimeCurrent(dt_struct);
   current_hour = dt_struct.hour;
   current_day = dt_struct.day_of_week;
   //Handlers for different indicators. The prices used is 'TYPICAL_PRICE', which is:
   // (high+low+close)/3.
   handle_MA2 = iMA(NULL,PERIOD_H1,MA2Period,0,MODE_SMA,PRICE_TYPICAL);
   handle_MA1 = iMA(NULL,PERIOD_H1,MA1Period,0,MODE_SMA,PRICE_TYPICAL);
   handle_MACD = iMACD(NULL,PERIOD_H1,MACDFastEMA,MACDSlowEMA,MACDSignalPeriod,PRICE_TYPICAL);
   handle_RSI = iRSI(NULL,PERIOD_H1,RSIPeriod,PRICE_TYPICAL);
   handle_DMI = iADX(NULL,PERIOD_H1,ADXPeriod);
   BAL = 0;
//---
   return(0);
  }
  
void get_current_conviction()
{
      double ma1[2];
      double ma2[2];
      double macd_main[3];
      double macd_signal[3];
      double rsi[2];
      double dmi_plusline[2];
      double dmi_minusline[2];
      MqlRates rt[2];
      int count[3];
      
      
      
            //get Moving Averages data for current bar.
      count[0] = CopyBuffer(handle_MA1,0,1,2,ma1);
      count[1] = CopyBuffer(handle_MA2,0,1,2,ma2);
     if(count[0]!=2 && count[1]!=2){
      //Print("CopyBuffer from iMA failed, no data...");
      return;
     }
     
            //get MACD for current and last bar.
     count[0] = CopyBuffer(handle_MACD,0,1,3,macd_main);
     count[1] = CopyBuffer(handle_MACD,1,1,3,macd_signal);
     if(count[0]!=3 && count[1]!=3){
      //Print("CopyBuffer from iMACD failed, no data...");
      return;
     }
     
            //get RSI for current and last bar
     count[0] = CopyBuffer(handle_RSI,0,1,2,rsi);
     if(count[0]!=2 && count[1]!=2){
         //Print("CopyBuffer from iRSI failed, no data...");
         return;
     }
     
            //get DMI for current and last bar.
     count[0] = CopyBuffer(handle_DMI,1,1,2,dmi_plusline);
     count[1] = CopyBuffer(handle_DMI,2,1,2,dmi_minusline);
     if(count[0]!=2 && count[1]!=2){
      //Print("CopyBuffer from iADX failed, no data from DMI indicator...");
      return;
     }
     
            //get Price Data for current and last bar.
     if(CopyRates(NULL,_Period,0,2,rt)!=2){
      //Print("CopyRates for ",_Symbol," failed, no historical price data...");
      return;
     }
     //Print("/////--------------START------------------//////");
     ENUM_ORDER_TYPE signal=WRONG_VALUE;
     
     //start to check indicators
     
     //Check MAs
     double ma_contribution = 0;
     //ma_contribution = (ma1[0] - ma2[0])/((ma1[0]+ma2[0])/2);
     if(ma1[0]>ma2[0]){
      ma_contribution = 1;
      //Print("MAs give buy signal!",ma_contribution);
     }else{
      ma_contribution = -1;
      //Print("MAs give sell signal!",ma_contribution);
     }
     
     /*Check for MACD signal:
        Check if current difference between signal and main line is larger than
        one and two bars earlier.
        Also check that all three points indicate the same direction.
     */
     double var[3];
     double macd_contribution = 0;
     var[0] = macd_main[0] - macd_signal[0];
     var[1] = macd_main[1] - macd_signal[1];
     var[2] = macd_main[2] - macd_signal[2];
     //macd_contribution = var[2];///((MathAbs(macd_main)+MathAbs(macd_signal))/2);
     if(MathAbs(var[2]) > MathAbs(var[1]) /*&& MathAbs(var[2]) > MathAbs(var[0])*/){
       if(var[2] > 0 && var[1] > 0 && var[0] > 0 /*&& macd_main[1] > 0*/){
         macd_contribution = 2;
         //Print("MACD gives a buy signal!",macd_contribution);
       }
       if(var[2] < 0 && var[1] < 0 && var[0] < 0 /*&& macd_main[1] < 0*/){
         macd_contribution = -2;
         //Print("MACD gives a sell signal!",macd_contribution);
       }
     }else{
      //Print("The MACD gives no conclusive signal","///",var[2],"///",var[1],"///",var[0]);
      macd_contribution = 0;
     }
     
     /*Check for RSI Signal
         Check the last bar for whether there is an indicator or not.
     */
     
     double rsi_contribution = 0;
     
     if(rsi[0] > 70){
         rsi_contribution = -1;
     }else if(rsi[0] < 30){
         rsi_contribution = 1;
     }
     
     /*Check for DMI signal
        Check the last point for the relative position of the plus and the
        minus line. 
     */
     double dmi_contribution = 0;
     //dmi_contribution = (dmi_plusline[1] - dmi_minusline[1])/(dmi_plusline[1]+dmi_minusline[1]);
     if((dmi_plusline[0]>ADXMinimum && dmi_minusline[0]<ADXMinimum) || (dmi_minusline[0]>ADXMinimum && dmi_plusline[0]<ADXMinimum)){
        if(dmi_plusline[0]>dmi_minusline[0]){
            dmi_contribution = 1;
            //Print("The DMI indicator gives a buy signal!",dmi_contribution);
        }else{
            dmi_contribution = -1;
            //Print("The DMI indicator gives a sell signal!",dmi_contribution);
        }
     }else{
      //Print("The DMI indicator gives no conclusive signal!",dmi_plusline[0],"///",dmi_minusline[0]);
      dmi_contribution = 0;
     }
     double total_conviction = ma_contribution+macd_contribution+rsi_contribution;
     conviction[0] = total_conviction;
     conviction[1] = ma_contribution;
     conviction[2] = macd_contribution;
     conviction[3] = rsi_contribution;
     conviction[4] = dmi_contribution;
     
     //Print("MA:"+ma_contribution+" MACD:"+macd_contribution+" DMI:"+dmi_contribution+" RSI:"+rsi_contribution+ " // TOTAL: "+total_conviction);
     //Print("/////--Total Conviction: ",total_conviction,"-------------//////");
     //Print("/////------------",PeriodSeconds(_Period),"-------------//////");
} 

double PositionSize(){
   double price=0.0;
   double margin=0.0;
//--- select lot size
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))               return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin)) return(0.0);
   if(margin<=0.0)                                               return(0.0);
   
   double lot = NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)*MaximumRisk/(sl_pips*10),2);
   //double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)*MaximumRisk/margin,2);

   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);
   
   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol) lot=minvol;

   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol) lot=maxvol;
   
   //--- return trading volume
   return(lot);
   
}

bool OpenPosition(ENUM_ORDER_TYPE direction){
   handle_ATR = iATR(NULL,PERIOD_H1,ATRPeriod);
      double atr[];
      //get ATR Value for comparison with MAs
      int count;
      count = CopyBuffer(handle_ATR,0,0,2,atr);
      if(count != 2){
         Print("CopyBuffer from iATR failed, no data...");
         return 0;
      }
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)){
      double entryprice = SymbolInfoDouble(_Symbol,direction==ORDER_TYPE_SELL ? SYMBOL_BID:SYMBOL_ASK);
      double lots = PositionSize();
      double sl=0.0;
      if(direction == ORDER_TYPE_BUY){
         sl = entryprice - atr[0];
      }
      if(direction == ORDER_TYPE_SELL){
         sl = entryprice + atr[0];
      }
      printf("Stoploss price: %G, entryprice: %G, sl_pips: %G",sl,entryprice,sl_pips);
      CTrade trade;
          bool executed = trade.PositionOpen(_Symbol,direction,lots,entryprice,sl,0);   
          return executed;
   }
   return false;
}
void ClosePosition(){
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)){
      printf("ACCOUNT_BALANCE =  %G",AccountInfoDouble(ACCOUNT_BALANCE));
      CTrade trade;
      trade.PositionClose(_Symbol,3);
      printf("ACCOUNT_BALANCE =  %G",AccountInfoDouble(ACCOUNT_BALANCE));
   }
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
            
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   TimeCurrent(dt_struct);
   if(current_day != dt_struct.day_of_week){
      current_hour = dt_struct.hour - 1;
      current_day = dt_struct.day_of_week;
   }
   if(current_hour <= dt_struct.hour - 1){
      get_current_conviction();
      //Print("MA:"+conviction[1]+" MACD:"+conviction[2]+" DMI:"+conviction[4]+" RSI:"+conviction[3]+ " // TOTAL: "+conviction[0]);
      if(MathAbs(conviction[0]) >= 3){
         if(!PositionSelect(_Symbol)){
            ENUM_ORDER_TYPE direction;
            if(conviction[0] > 0)   {
               direction = ORDER_TYPE_BUY;
               Print("BUYF");   
            }else{
               direction = ORDER_TYPE_SELL;
               Print("SELLF");
            }   
            OpenPosition(direction);      
            tradeActive = true;
         }else{
            long current_direction;
            datetime open_time;
            PositionSelect(_Symbol);
            PositionGetInteger(POSITION_TIME,open_time);
            PositionGetInteger(POSITION_TYPE,current_direction);
            //printf("Current Direction: %G and Current Conviction: %G",current_direction,conviction[0]);
            if(current_direction == POSITION_TYPE_BUY && conviction[0] < 0){ //&& open_time + PeriodSeconds(_Period) < TimeCurrent()
               Print("SELL");
               ClosePosition();
               OpenPosition(ORDER_TYPE_SELL);
               return;
            }
            if(current_direction == POSITION_TYPE_SELL && conviction[0] > 0){ //&& open_time + PeriodSeconds(_Period) < TimeCurrent()
               Print("BUY");
               ClosePosition();
               OpenPosition(ORDER_TYPE_BUY);
               return;
            }
         }
      }else if(MathAbs(conviction[0]) <= 0){
         if(PositionSelect(_Symbol)){
            ClosePosition();      
         }
         //Print(conviction);
      }else{
         //Print(conviction[0]);
      }
      current_hour = dt_struct.hour;
   }
  }
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Trade function                                                   |
//+------------------------------------------------------------------+
void OnTrade()
  {
//---
   
  }
//+------------------------------------------------------------------+