//+------------------------------------------------------------------+

//| HedgeV03.mq5 |
//| Jay |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Jay"
#property link "https://www.mql5.com"
#property version "1.00"

//\[] {} ||

#include <Trade/Trade.mqh>
CTrade *trade;

input ENUM_TIMEFRAMES InpTimeframe=PERIOD_CURRENT; // Timeframe

for trend analysis
input double InpLotsize = 0.01; // Lotsize
input double InpLotMultiplier = 2; // Lotsize multiplier
input int InpPeriod = 5; // Period for market move calculation
input int InpTakeProfitPips = 50; // Take Profit in Pips
input int InpStopLossPips = 100; // Stop Loss in Pips
input int InpHedgeDistPips = 50; // Hedge Distance in Pips
input string InpTradeComment = __FILE__; // Trade Comment
input ulong InpMagicNumber = 20202020; // EA Magic Number
input int InpADXPeriod = 14; // ADX Period
input int InpADXValue = 20; // ADX tolerance limit

double takeProfit = 0;
double stopLoss = 0;
double Ask = 0;
double Bid = 0;
double openPrice=0;
double orderTP=0;
double hedgeDist=0;
double mfactor=1;

bool upTrend = false;

bool downTrend = false;

int HandleADX;
double ADXBuffer[];

static double maximumAccountBalance=0;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit(){
 trade = new CTrade();
trade.SetExpertMagicNumber(InpMagicNumber);

switch(_Digits){
case(4):
mfactor = 1;
break;
case(5):
mfactor = 10;
break;
default:
mfactor = 1;
break;
}

takeProfit = NormalizeDouble((InpTakeProfitPips)*mfactor*_Point, _Digits);

//orderTP = takeProfit;
orderTP = NormalizeDouble((InpTakeProfitPips*2)*mfactor*_Point, _Digits);
hedgeDist = NormalizeDouble((InpHedgeDistPips)*mfactor*_Point, _Digits);
stopLoss = NormalizeDouble(InpStopLossPips*mfactor*_Point, _Digits);

maximumAccountBalance = AccountInfoDouble(ACCOUNT_BALANCE);

HandleADX = iADX(_Symbol,InpTimeframe, InpADXPeriod);

if(HandleADX==INVALID_HANDLE) return(INIT_FAILED);

ArraySetAsSeries(ADXBuffer, true);

return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason){
if(HandleADX!=INVALID_HANDLE) IndicatorRelease(HandleADX);
delete trade;
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick(){

//if(!NewBar()) return;

bool signalOpenBuy = false;

bool signalOpenSell = false;
bool signalCloseBuy = false;
 bool signalCloseSell = false;

double sellStopPrice=0;
double buyStopPrice=0;

double totalBuyProfit = 0;
double totalSellProfit = 0;
double totalProfit = 0;

int cnt = CopyBuffer(HandleADX, 0, 0, 3, ADXBuffer);

Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);

datetime now = TimeLocal();

static double todaysProfit = 0;
static string today = "";
static double todaysBalance = 0;

if(today==TimeToString(TimeLocal(),TIME_DATE)) // date has not changed yet

todaysProfit = AccountInfoDouble(ACCOUNT_EQUITY)-todaysBalance;
else{
todaysBalance = AccountInfoDouble(ACCOUNT_BALANCE); //Reset starting
balance of the day
todaysProfit = 0; //Reset today's profit to ZERO.
today = TimeToString(TimeLocal(),TIME_DATE);
}

if(maximumAccountBalance<AccountInfoDouble(ACCOUNT_BALANCE))
maximumAccountBalance=AccountInfoDouble(ACCOUNT_BALANCE);

double highestPrice=iHigh(_Symbol,InpTimeframe,1);
double lowestPrice=iLow(_Symbol,InpTimeframe,1);
double highestClose=iClose(_Symbol,InpTimeframe,1);
double lowestClose=iClose(_Symbol,InpTimeframe,1);

double avgHLC1 = (iHigh(_Symbol,InpTimeframe,1) +

iLow(_Symbol,InpTimeframe,1) + iClose(_Symbol,InpTimeframe,1))/3;
double highestAvgHLC = avgHLC1;
double lowestAvgHLC = avgHLC1;

for(int i=1; i<=InpPeriod; i++){

double avgHLC = (iHigh(_Symbol,InpTimeframe,i) +
iLow(_Symbol,InpTimeframe,i) + iClose(_Symbol,InpTimeframe,i))/3;
if(avgHLC > highestAvgHLC) highestAvgHLC=avgHLC;
if(avgHLC < lowestAvgHLC) lowestAvgHLC=avgHLC;

if(iHigh(_Symbol,InpTimeframe,i)>highestPrice) highestPrice =
iHigh(_Symbol,InpTimeframe,i);
if(iLow(_Symbol,InpTimeframe,i)<lowestPrice) lowestPrice =
iLow(_Symbol,InpTimeframe,i);
if(iClose(_Symbol,InpTimeframe,i)>highestClose) highestClose =
iClose(_Symbol,InpTimeframe,i);
if(iClose(_Symbol,InpTimeframe,i)<lowestClose) lowestClose =
iClose(_Symbol,InpTimeframe,i);
}

upTrend = false; downTrend =false;

//if(iHigh(_Symbol,InpTimeframe,0)>highestPrice &&
iClose(_Symbol,InpTimeframe,0)>highestClose) upTrend=true;
//if(iLow(_Symbol,InpTimeframe,0)<lowestPrice &&
iClose(_Symbol,InpTimeframe,0)<lowestClose) downTrend=true;

if(iHigh(_Symbol,InpTimeframe,0)>highestPrice && ADXBuffer[0]>InpADXValue)

upTrend=true;
if(iLow(_Symbol,InpTimeframe,0)<lowestPrice && ADXBuffer[0]>InpADXValue)
downTrend=true;

//if(avgHLC1>highestAvgHLC && ADXBuffer[0]>InpADXValue) upTrend=true;

//if(avgHLC1<lowestAvgHLC && ADXBuffer[0]>InpADXValue) downTrend=true;

//Fetch no. of BUY and SELL positions, open prices & lotsize of the last BUY or
SELL order
double lastBuyLot = 0;
double lastSellLot = 0;

int nBuyPositions = 0; // Number of Buy positions

int nSellPositions = 0; // Number of Sell positions

int nBuyStopOrders = 0; // Number of Buystop orders

int nSellStopOrders = 0; // Number of Sellstop orders

ulong lastBuyTicket = 0;
ulong lastSellTicket = 0;

ulong lastBuyStopTicket = 0;
ulong lastSellStopTicket = 0;

double lastBuyStopLot = 0;
double lastSellStopLot = 0;

for (int i=PositionsTotal()-1; i>=0 ; i--){

ulong myTicket = PositionGetTicket(i);
if (PositionSelectByTicket(myTicket) &&
PositionGetString(POSITION_SYMBOL)==_Symbol &&
PositionGetInteger(POSITION_MAGIC)==InpMagicNumber){
if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) {
nBuyPositions++;
 if (PositionGetDouble(POSITION_VOLUME) > lastBuyLot){
lastBuyLot = PositionGetDouble(POSITION_VOLUME);
lastBuyTicket = myTicket;
}
}
if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL){
nSellPositions++;
if (PositionGetDouble(POSITION_VOLUME) > lastSellLot){
lastSellLot = PositionGetDouble(POSITION_VOLUME);
lastSellTicket = myTicket;
}
}
}
}

for (int i=OrdersTotal()-1; i>=0; i--){

ulong myTicket = OrderGetTicket(i);
if (OrderSelect(myTicket) && OrderGetString(ORDER_SYMBOL)==_Symbol &&
OrderGetInteger(ORDER_MAGIC)==InpMagicNumber){
if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP){
nBuyStopOrders++;
lastBuyStopTicket = myTicket;
lastBuyStopLot=OrderGetDouble(ORDER_VOLUME_INITIAL);
}
if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP){
nSellStopOrders++;
lastSellStopTicket = myTicket;
lastSellStopLot=OrderGetDouble(ORDER_VOLUME_INITIAL);
}
}
}

bool closeAllPositions=false;
if((PositionSelectByTicket(lastBuyTicket) &&
Ask>PositionGetDouble(POSITION_PRICE_OPEN)+takeProfit) ||
(PositionSelectByTicket(lastSellTicket) &&
Bid<PositionGetDouble(POSITION_PRICE_OPEN)-takeProfit)){
closeAllPositions = true;
}

/*
//DON'T RISK TOO MUCH MONEY
//if((MathMax(nBuyPositions, nSellPositions)>3 &&
AccountInfoDouble(ACCOUNT_PROFIT)>0) ||
AccountInfoDouble(ACCOUNT_EQUITY)<todaysBalance*0.90)
if(AccountInfoDouble(ACCOUNT_EQUITY)<todaysBalance*0.90){
Print("10% loss limit reached...... Closing all positions");
closeAllPositions=true;
}
*/
 if(closeAllPositions){
ulong myTicket;
for (int i=PositionsTotal()-1; i>=0 ; i--){ //Close all open positions
myTicket = PositionGetTicket(i);
if (PositionSelectByTicket(myTicket) &&
PositionGetString(POSITION_SYMBOL)==_Symbol &&
PositionGetInteger(POSITION_MAGIC)==InpMagicNumber)
closePosition(myTicket);
}

for (int i=OrdersTotal()-1; i>=0; i--){ //Delete all pending STOP orders
myTicket = OrderGetTicket(i);
if (OrderSelect(myTicket) && OrderGetString(ORDER_SYMBOL)==_Symbol
&& OrderGetInteger(ORDER_MAGIC)==InpMagicNumber)
deletePendingOrder(myTicket);
}
//Print("Closing all positions");
return;
}

//===============================================================
================================================================
===========

double stopLotSize = 0;
double stopOpenPrice = 0;

if(nBuyPositions>0){ //Place SELLSTOP order at hedge distance below last

BUY position
if(PositionSelectByTicket(lastBuyTicket)){
if(nSellStopOrders==0) { // If no SELLSTOP order exists
stopOpenPrice = MathMin(PositionGetDouble(POSITION_PRICE_OPEN)-
hedgeDist, Bid);
if(nSellPositions==0 && nBuyPositions==1) //If there is a single BUY
order
stopLotSize = 3*PositionGetDouble(POSITION_VOLUME);
else
stopLotSize = InpLotMultiplier*PositionGetDouble(POSITION_VOLUME);

if(nSellPositions==0 || lastBuyLot>lastSellLot)
if(!
trade.SellStop(stopLotSize,stopOpenPrice,_Symbol,stopOpenPrice+stopLoss,stopO
penPrice-orderTP,0,0,InpTradeComment))
Print("SELLSTOP failed. Return code=",trade.ResultRetcode(), ". Code
description: ",trade.ResultRetcodeDescription());
}
}
}
 if(nSellPositions>0) { //Place BUYSTOP order at hedge distance above last
SELL position
if(PositionSelectByTicket(lastSellTicket)){
if(nBuyStopOrders==0) { // If no BUYSTOP order exists
stopOpenPrice = MathMax(PositionGetDouble(POSITION_PRICE_OPEN)
+hedgeDist, Ask);
if(nSellPositions==1 && nBuyPositions==0) //If there is a single SELL
order
stopLotSize = 3*PositionGetDouble(POSITION_VOLUME);
else
stopLotSize = InpLotMultiplier*PositionGetDouble(POSITION_VOLUME);

if(nBuyPositions==0 || lastSellLot>lastBuyLot)
if(!trade.BuyStop(stopLotSize,stopOpenPrice,_Symbol,stopOpenPrice-
stopLoss,stopOpenPrice+orderTP,0,0,InpTradeComment))
Print("BUYSTOP failed. Return code=",trade.ResultRetcode(), ". Code
description: ",trade.ResultRetcodeDescription());
}
}
}

double initialLotsize = InpLotsize;

if(nBuyPositions==0 && nSellPositions==0){
if(OrderSelect(lastBuyStopTicket))
deletePendingOrder(lastBuyStopTicket);

if(OrderSelect(lastSellStopTicket))
deletePendingOrder(lastSellStopTicket);

//if(upTrend){
if(upTrend || lastProfitableDealType()==DEAL_TYPE_SELL){
if(!trade.Buy(initialLotsize,_Symbol, Ask, Ask-stopLoss, Ask+orderTP,
InpTradeComment))
Print("BUY trade failed. Return code=",trade.ResultRetcode(), ". Code
description: ",trade.ResultRetcodeDescription(), " Ask = ", Ask );
}
else
//if(downTrend){ //Downtrend - place a SELL order
if(downTrend || lastProfitableDealType()==DEAL_TYPE_BUY){
if(!trade.Sell(initialLotsize,_Symbol, Bid,Bid+stopLoss,Bid-orderTP,
InpTradeComment))
Print("SELL trade failed. Return code=",trade.ResultRetcode(), ". Code
description: ",trade.ResultRetcodeDescription(), " Bid = ", Bid);
}
}

Comment("\nUpTrend = ", upTrend, " DownTrend = ", downTrend, " ADX Value = ",
NormalizeDouble(ADXBuffer[0],0),
"\nTakeProfit = ", InpTakeProfitPips, " Stoploss = ", InpStopLossPips, " Hedge
Distance = " ,InpHedgeDistPips, " Initial Lotsize = ", initialLotsize,
"\nHighest avgHLC = ", NormalizeDouble(highestAvgHLC,_Digits), " lowest
avgHLC = ", NormalizeDouble(lowestAvgHLC,_Digits),
" AvgHLC1 = ", NormalizeDouble(avgHLC1,_Digits),
"\nHighest Price = ", NormalizeDouble(highestPrice,_Digits), " Lowest Price =
", NormalizeDouble(lowestPrice,_Digits),
"\n",
"\n",
"\n#Buy Positions= ", nBuyPositions, " #SELLSTOP orders = ",
nSellStopOrders, " LastBuyLot = ", lastBuyLot, " SellStop Lot = ", lastSellStopLot,
"\n#Sell Positions = ", nSellPositions, " #BUYSTOP orders = ",
nBuyStopOrders, ", LastSellLot = ", lastSellLot, " BuyStop Lot = ", lastBuyStopLot,
"\n",
"\nDate", today, " Opening Balance = ", todaysBalance, " Day's profit = ",
NormalizeDouble(todaysProfit,2),
" Profit in % - ", NormalizeDouble(todaysProfit*100/todaysBalance, 2),
"\n",
"\nAccount balance = ",
NormalizeDouble(AccountInfoDouble(ACCOUNT_BALANCE),2), " Maximum
Account Balance = ", maximumAccountBalance,
"\nAccount equity = ",
NormalizeDouble(AccountInfoDouble(ACCOUNT_EQUITY),2),
"\nAccount Profit = ",
NormalizeDouble(AccountInfoDouble(ACCOUNT_PROFIT),2),
"\nLast Profitable Deal Type = ", lastProfitableDealType(),
"\n"
);

return;
}

//======================================= CLOSE A POSITION

================================================================
===============================
void closePosition(ulong myTicket){
int Retries=0;
while(!trade.PositionClose(myTicket) && Retries <=5){
Print("Failed to close position ", myTicket, " Return
code=",trade.ResultRetcode(), ". Code description:
",trade.ResultRetcodeDescription());
Sleep(6000);
Retries++;
}
}

//======================================= DELETE BUYSTOP or

SELLSTOP orders
================================================================
==============
void deletePendingOrder(ulong myTicket){
if(!trade.OrderDelete(myTicket))
Print("Failed to delete STOP order ", myTicket, " Return
code=",trade.ResultRetcode(), ". Code description:
",trade.ResultRetcodeDescription());
}

void trailStopLoss(ulong myTicket){

double newStopLoss = 0;

if(PositionSelectByTicket(myTicket)){
double CurrentStopLoss = PositionGetDouble(POSITION_SL);
if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY){
newStopLoss = Ask-stopLoss/2;
if (CurrentStopLoss==0 || CurrentStopLoss<newStopLoss) //New stop
loss if price has gone up
if(!trade.PositionModify(myTicket,
newStopLoss,PositionGetDouble(POSITION_TP)))
Print("TrailStop - Failed to modify BUY position ", myTicket, " Return
code=",trade.ResultRetcode(), ". Code description:
",trade.ResultRetcodeDescription());
}
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
newStopLoss = Bid+stopLoss/2;
if (CurrentStopLoss==0 || CurrentStopLoss>newStopLoss) //New stop
loss if price has gone down
if(!trade.PositionModify(myTicket,newStopLoss,
PositionGetDouble(POSITION_TP)))
Print("TrailStop - Failed to modify SELL position ", myTicket, " Return
code=",trade.ResultRetcode(), ". Code description:
",trade.ResultRetcodeDescription());
}
}
}

//Find direction of last profitable trade

ENUM_DEAL_TYPE lastProfitableDealType(){
HistorySelect(TimeCurrent()-86400, TimeCurrent()); // Order history for last 24
hours.
ulong myTicket;
for(int i = HistoryDealsTotal()-1; i>=0; i--){
myTicket=HistoryDealGetTicket(i);
if(HistoryDealGetString(myTicket,DEAL_SYMBOL)==_Symbol &&
HistoryDealGetInteger(myTicket,DEAL_MAGIC)==InpMagicNumber)
if(HistoryDealGetDouble(myTicket, DEAL_PROFIT) > 0 &&
HistoryDealGetInteger(myTicket,DEAL_ENTRY)==DEAL_ENTRY_OUT) //Deal
triggered by TakeProfit
 return HistoryDealGetInteger(myTicket, DEAL_TYPE);
}
return DEAL_TYPE_CORRECTION;
}