//+------------------------------------------------------------------+
//|                                                       BarFly.mq4 |
//|      Copyright © 2011, Markdshark, Cave Ceteris Investments, LLC |
//|                                       http://www.caveceteris.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, Markdshark, Cave Ceteris Investments, LLC"
#property link      "http://www.caveceteris.com"

//////////////////////////////////////////////////////////////////////////////
/* Revision History
 	Date		Author		Version	Changes
 	8/6/11	markdshark	1			Coding start

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

#import "stdlib.ex4"
	string ErrorDescription(int error_code);

#import

//--------- External Variables
extern string GeneralSettings = "---------------------------";

extern double externLot=1;
extern double maxLots=2;
extern double accountFactor=0.17; //%age of acct value

extern string s6Section = "--------Barfly settings--------";
extern double flyFactor=3;
extern double capturePips = 100;
//-
extern string comment="barFly";

//-----------Internal Variables
bool newBar=false, weekendAlert;
bool s6FirstTime=true;
bool tradable=true;

double lot;
double stopLoss, sarStopLoss, lastSarStopLoss, sandLineTest;
double myPoint,tickValue;
double pipsLostThisBar;

int trend, ticket, s6LastTrade=0;
int arrayStrat6Tickets[10];

string s6Comment="barFly";
static datetime currBar;

///////////////////////////////////////////////
// init
///////////////////////////////////////////////
void init(){
	myPoint = setPoint();
	tickValue = MarketInfo(Symbol(),MODE_TICKVALUE);
	ArrayResize(arrayStrat6Tickets, externLot);	///This will get screwed if you use a fractional value for externLots
	ArrayInitialize(arrayStrat6Tickets,-1);	

}

///////////////////////////////////////////////
// initializeTradeFlags
///////////////////////////////////////////////
void initializeStrat6Flags(){	
	pipsLostThisBar = 0;
}

///////////////////////////////////////////////
// setVariables
///////////////////////////////////////////////
void setVariables(){
}


//////////////////////////////////////
// Start
//////////////////////////////////////
int start(){

	if(currBar != Time[0] ){
		currBar = Time[0];
		newBar=true;
	} else newBar=false;

	setVariables();	
	barFly();

}



//////////////////////////////////////
// Barfly
//////////////////////////////////////
void barFly(){
	int openPositions=getOpenPositions(arrayStrat6Tickets, s6Comment);		
	
	if(newBar) {
		tradable=true;
		initializeStrat6Flags();
	}
	
	//Trade
	int trend=trend();
	if (openPositions < 1 ) {
		if ( (trend==1 || trend==2) && tradable ){
			trade(trend, s6LastTrade, arrayStrat6Tickets, externLot, s6Comment);
		}
	}

	//And Manage	
	for (int l=0; l<ArrayRange(arrayStrat6Tickets,0); l++){
		ticket=arrayStrat6Tickets[l];
		if (ticket!=-1){
			if (OrderSelect(ticket,SELECT_BY_TICKET && OrderCloseTime()==0)){
				if(OrderType()==OP_BUY){
					if (pipsLostThisBar>0 && Bid-OrderOpenPrice()> flyFactor*pipsLostThisBar
						|| Bid-OrderOpenPrice() > capturePips
					){
						Alert("FLYFACTOR HIT for ",Bid-OrderOpenPrice()," PIPS");
						closeAll(arrayStrat6Tickets);
						tradable=false;
					}
				} else
				if(OrderType()==OP_SELL){
					if (pipsLostThisBar>0 && OrderOpenPrice()-Ask> flyFactor*pipsLostThisBar
						|| OrderOpenPrice()-Ask > capturePips
					){
						Alert("FLYFACTOR HIT FOR",OrderOpenPrice()-Ask," PIPS" );
						closeAll(arrayStrat6Tickets);
						tradable=false;
					}
				}
				closeTradeIfNeeded(arrayStrat6Tickets);	
			}
		}
	}
}
//////////////////////////////////////////////////////////////////////////
// TRADE SECTION
//////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////
// trade
///////////////////////////////////////////////
bool trade(int trend, int& lastTrade, int& ticketArray[], int lotFactor, string comment){
	bool traded=false;
	if (trend==1){
		if (buy(ticketArray, lotFactor, comment)){
			lastTrade=1;
			traded=true;
		}
	} else if (trend==2){
		if (sell(ticketArray, lotFactor, comment)){
			lastTrade=2;
			traded=true;
		}
	}
	
	if (traded) {
		Sleep(500);
	}
	return(traded);
}

///////////////////////////////////////////////
// trend
///////////////////////////////////////////////
int trend() {
	if (	Bid>Open[0]+flyFactor*(Ask-Bid) 
		){
		return (1);
	}
	else 
	if (	Ask<Open[0]-flyFactor*(Ask-Bid) 
		){
		return (2);
	} else return (0);
}

///////////////////////////////////////////////
// closeTradeIfNeeded
///////////////////////////////////////////////
void closeTradeIfNeeded(int& ticketArray[]){
	if (OrderType()==OP_BUY){
		if(buyCloseCondition() ){
			closeAll(ticketArray);
			pipsLostThisBar+=(2*(Ask-Bid));
			Alert("TOTAL PIPS LOST: ",pipsLostThisBar);
		}
	} else if (OrderType()==OP_SELL){
		if (sellCloseCondition() ) {
			closeAll(ticketArray);
			pipsLostThisBar+=(2*(Ask-Bid));
			Alert("TOTAL PIPS LOST: ",pipsLostThisBar);

		}
	}		
	if (newBar) pipsLostThisBar=0;
}

///////////////////////////////////////////////
// buyCloseCondition
///////////////////////////////////////////////
bool buyCloseCondition(){

	if (Ask < Open[0]-(Ask-Bid)
		|| newBar
   ){
		Alert("S6 BUY CLOSE CONDITION for ",Symbol());
		return(true);
	} else return (false);
}

///////////////////////////////////////////////
// sellCloseCondition
///////////////////////////////////////////////
bool sellCloseCondition(){

	if (Bid > Open[0]+(Ask-Bid)
		|| newBar
	){
      	Alert("SELL CLOSE CONDITION for ",Symbol());
      	
      	return(true);
	} else return (false);
} 


////////////////////////////////////////////////////
// getOpenPositions
///////////////////////////////////////////////////
int getOpenPositions(int& ticketArray[], string comment) {

	ArrayInitialize(ticketArray,0);
	int ticketIndex=0;
	for(int j=0; j<OrdersTotal();j++){
		if(OrderSelect(j, SELECT_BY_POS))
			if(Symbol()==OrderSymbol() && OrderComment()==comment)
				if	(OrderType() == OP_BUY || OrderType() == OP_SELL) {
					ticketArray[ticketIndex]=OrderTicket();
					ticketIndex++;
				}
	}
	return (ticketIndex);
}


///////////////////////////////////////////////
// closeAll
//////////////////////////////////////////////
void closeAll(int ticketArray[]) {
   bool success;
   int timesthruLoop = 0;
   int maxTimesToLoop = 300;
   int totalOrders = ArrayRange(ticketArray,0);
	for (int i = 0;i<totalOrders; i++) {
		int ticket=ticketArray[i];
		if (OrderSelect(ticket, SELECT_BY_TICKET) && OrderCloseTime()==0) {
			Alert("Closing ticket: ",ticket);
			for (int j = 1; j <= 10; j++) {
				RefreshRates();
				if (OrderType() == OP_BUY){ 
					if(OrderClose(ticket, OrderLots(), Bid, 0)){
						Alert(OrderTicket()," closed for ", OrderProfit());
						break;
					}
				}
				else 
				if (OrderType() == OP_SELL){
					if(OrderClose(ticket, OrderLots(), Ask, 0)) {
						Alert(OrderTicket()," closed for ", OrderProfit());
						break;
					}
				}
				Sleep(500);
			}
      }
      if (IsStopped()) break;
      timesthruLoop++;
   }
}


///////////////////////////////////////////////
// buy
///////////////////////////////////////////////
bool buy(int& ticketArray[], int lotFactor, string comment){
	double lot;
	bool success=false;
	ArrayInitialize(ticketArray, -1);
	int index=0,ticket=0;
	if (externLot > 0) lot=externLot; else lot=getMaxLots(accountFactor, lotFactor, maxLots);
	
	for (int tradeNumber=0; tradeNumber<lotFactor; tradeNumber++){
	 	ticket=OrderSend(Symbol(),OP_BUY,lot,Ask,0,0,0,comment,(tradeNumber+1)*11);
		if (ticket < 0) tradeErrorAlert(GetLastError());
		else {
			success=true;
			Alert("Opened ticket: ",ticket);
			ticketArray[index]=ticket;
			index++;
		}
	}
	return(success);
}


///////////////////////////////////////////////
// sell
///////////////////////////////////////////////
bool sell(int& ticketArray[], int lotFactor, string comment){
	double lot;
	bool success=false;
	ArrayInitialize(ticketArray, -1);
	int index=0,ticket=0;
	if (externLot > 0) lot=externLot; else lot=getMaxLots(accountFactor, lotFactor, maxLots);
	
	for (int tradeNumber=0; tradeNumber<lotFactor; tradeNumber++){
		ticket=OrderSend(Symbol(),OP_SELL,lot,Bid,0,0,0,comment,(tradeNumber+1)*11);
		if (ticket < 0) tradeErrorAlert(GetLastError());
		else {
			success=true;
			Alert("Opened ticket: ",ticket);
			ticketArray[index]=ticket;
			index++;
		}
	}
	return(success);
}


///////////////////////////////////////////////////////////////////////////////////////
// Close trades (left in as example)
///////////////////////////////////////////////////////////////////////////////////////
/*bool closeTrade() {
	bool success=false;
	if (OrderType() == OP_SELL || OrderType() == OP_BUY) {
		for (int j = 1; j <= 10; j++) {
			Alert("CLOSING ORDER");
			RefreshRates();
			if (OrderType() == OP_BUY) success = OrderClose(OrderTicket(), OrderLots(), Bid, 0, Red);
			else if (OrderType() == OP_SELL) success = OrderClose(OrderTicket(), OrderLots(), Ask, 0, Red);
		
			if (!success) {
				Alert("CLOSE COMMAND RETURNED: ");
				int error=GetLastError();
				tradeErrorAlert(error );
			}
			
			if (success || error==136 || error==4108) return (true);
			Sleep(500);
		}
	}
	return(success);
}*/

///////////////////////////////////////////////
// getMaxLots
///////////////////////////////////////////////
double getMaxLots(double accountFactor, double lotFactor, double maxLots){
   double possibleLots = AccountFreeMargin()*accountFactor/MarketInfo(Symbol(),MODE_MARGINREQUIRED);
   double actualLots = possibleLots / lotFactor;
	double MINLOT = MarketInfo(Symbol(),MODE_MINLOT);
   if (actualLots < MINLOT) actualLots = MINLOT;
   if (actualLots > maxLots) actualLots = maxLots;
  	if (MINLOT<0.1) return(NormalizeDouble(actualLots,2)); else return(NormalizeDouble(actualLots,1));
}

///////////////////////////////////////////////
// setPoint
///////////////////////////////////////////////
double setPoint()
{
   double mPoint;
   if (Digits < 4)
      mPoint = 0.01;
   else
      mPoint = 0.0001;
   return(mPoint);
}
///////////////////////////////////////////////
// tradeErrorAlert
///////////////////////////////////////////////
void tradeErrorAlert(int errorCode){
	Alert("TRADE ERROR! ",Symbol()," >>>>>>>",ErrorDescription(errorCode)," ",errorCode);
}