//+------------------------------------------------------------------+
//|                                                  ManualManager.mq5
//|                        Manual Orders Manager for EURUSD
//+------------------------------------------------------------------+
#property strict
#include <Trade/Trade.mqh>

CTrade trade;

//==================== INPUT ====================
input string TradeSymbol      = "EURUSD";
input double InitialSL_Pips   = 10.0;
input double InitialTP_Pips   = 10.0;
input double BETrigger_Pips   = 2.0;
input double BEOffset_Pips    = 0.5;

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

double PipValue()
{
   if(_Digits==3 || _Digits==5)
      return(_Point*10);
   return(_Point);
}

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

bool IsManualPosition()
{
   return(PositionGetInteger(POSITION_MAGIC)==0);
}

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

string GV_BE(ulong ticket)
{
   return("BE_DONE_"+(string)ticket);
}

string GV_MANUAL(ulong ticket)
{
   return("MANUAL_SL_"+(string)ticket);
}

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

bool AlreadyBreakEven(ulong ticket)
{
   return(GlobalVariableCheck(GV_BE(ticket)));
}

void MarkBreakEven(ulong ticket)
{
   GlobalVariableSet(GV_BE(ticket),TimeCurrent());
}

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

bool ManualSLChanged(ulong ticket)
{
   return(GlobalVariableCheck(GV_MANUAL(ticket)));
}

void MarkManualSL(ulong ticket)
{
   GlobalVariableSet(GV_MANUAL(ticket),TimeCurrent());
}

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

void ManagePosition()
{
   int total=PositionsTotal();

   double pip=PipValue();

   for(int i=total-1;i>=0;i--)
   {
      ulong ticket=PositionGetTicket(i);

      if(!PositionSelectByTicket(ticket))
         continue;

      string symbol=PositionGetString(POSITION_SYMBOL);

      if(symbol!=TradeSymbol)
      {
         Print("Ticket ",ticket," Ignored.");
         continue;
      }

      if(!IsManualPosition())
      {
         Print("Ticket ",ticket," Ignored.");
         continue;
      }

      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

      double open=PositionGetDouble(POSITION_PRICE_OPEN);
      double sl=PositionGetDouble(POSITION_SL);
      double tp=PositionGetDouble(POSITION_TP);

      double bid=SymbolInfoDouble(symbol,SYMBOL_BID);
      double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);

      //------------------------------------------
      // Initial SL
      //------------------------------------------
      if(sl==0)
      {
         double newSL;

         if(type==POSITION_TYPE_BUY)
            newSL=open-InitialSL_Pips*pip;
         else
            newSL=open+InitialSL_Pips*pip;

         if(trade.PositionModify(ticket,newSL,tp))
         {
            Print("Ticket ",ticket," Initial SL added.");
            continue;
         }
      }

      //------------------------------------------
      // Initial TP
      //------------------------------------------
      PositionSelectByTicket(ticket);

      sl=PositionGetDouble(POSITION_SL);
      tp=PositionGetDouble(POSITION_TP);

      if(tp==0)
      {
         double newTP;

         if(type==POSITION_TYPE_BUY)
            newTP=open+InitialTP_Pips*pip;
         else
            newTP=open-InitialTP_Pips*pip;

         if(trade.PositionModify(ticket,sl,newTP))
         {
            Print("Ticket ",ticket," Initial TP added.");
            continue;
         }
      }

      //------------------------------------------
      // Detect Manual SL change
      //------------------------------------------

      if(!AlreadyBreakEven(ticket))
      {
         double expectedSL;

         if(type==POSITION_TYPE_BUY)
            expectedSL=open-InitialSL_Pips*pip;
         else
            expectedSL=open+InitialSL_Pips*pip;

         if(sl!=0 && MathAbs(sl-expectedSL)>pip*0.2)
         {
            MarkManualSL(ticket);
            Print("Ticket ",ticket," Ignored.");
            continue;
         }
      }

      //------------------------------------------
      // Skip if manual SL modified
      //------------------------------------------

      if(ManualSLChanged(ticket))
      {
         Print("Ticket ",ticket," Ignored.");
         continue;
      }

      //------------------------------------------
      // BreakEven only once
      //------------------------------------------

      if(AlreadyBreakEven(ticket))
         continue;

      double profitPips;

      if(type==POSITION_TYPE_BUY)
         profitPips=(bid-open)/pip;
      else
         profitPips=(open-ask)/pip;

      if(profitPips>=BETrigger_Pips)
      {
         double beSL;

         if(type==POSITION_TYPE_BUY)
            beSL=open+BEOffset_Pips*pip;
         else
            beSL=open-BEOffset_Pips*pip;

         if(MathAbs(sl-beSL)>pip*0.1)
         {
            if(trade.PositionModify(ticket,beSL,tp))
            {
               MarkBreakEven(ticket);
               Print("Ticket ",ticket," BreakEven completed.");
            }
         }
      }

   }
}

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

int OnInit()
{
   Print("Manual Manager Started");
   return(INIT_SUCCEEDED);
}

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

void OnTick()
{
   ManagePosition();
}