Gold1

//+------------------------------------------------------------------+
//| EA: Execution & Risk Manager v1 (MT4 / MQL4)                     |
//| - Time window (Greece time via offset)                           |
//| - Max trades/day, max loss trades/day                             |
//| - Optional: one trade at a time                                  |
//| - Auto SL/TP (RR), break-even, trailing                           |
//+------------------------------------------------------------------+
#property strict

// ---------- Inputs ----------
input int    MagicNumber           = 260208;   // Unique ID for this EA
input double FixedLots             = 0.01;     // If UseFixedLots=true
input bool   UseFixedLots          = true;

input int    MaxTradesPerDay       = 4;
input int    MaxLossTradesPerDay   = 2;
input bool   OneTradeAtATime       = true;

input bool   UseTradeWindow        = true;
input int    GR_UTC_Offset_Hours   = 2;        // Greece offset from UTC (Feb = 2, summer often 3)
input int    TradeStartHourGR      = 14;       // e.g. 14:00
input int    TradeStartMinuteGR    = 0;
input int    TradeEndHourGR        = 18;       // e.g. 18:30
input int    TradeEndMinuteGR      = 30;

input bool   AutoSetSLTP           = true;
input int    StopLossPips          = 120;      // adjust per symbol volatility
input double RiskReward            = 2.0;      // TP = SL * RR

input bool   UseBreakEven          = true;
input int    BreakEvenAfterPips    = 80;       // when profit >= this, move SL to entry(+buffer)
input int    BreakEvenBufferPips   = 5;

input bool   UseTrailing           = true;
input int    TrailStartPips        = 120;      // start trailing after profit >= this
input int    TrailDistancePips     = 80;       // distance from price

// ---------- Helpers ----------
double PipValue()
{
   // For 5-digit / 3-digit brokers, 1 pip = 10 points
   if(Digits == 3 || Digits == 5) return(Point * 10);
   return(Point);
}

datetime GreeceTimeNow()
{
   // Use UTC time + GR offset (manual). This avoids dependency on broker server time.
   return(TimeGMT() + GR_UTC_Offset_Hours * 3600);
}

bool IsInTradeWindow()
{
   if(!UseTradeWindow) return(true);

   datetime grNow = GreeceTimeNow();
   int h = TimeHour(grNow);
   int m = TimeMinute(grNow);

   int cur = h*60 + m;
   int start = TradeStartHourGR*60 + TradeStartMinuteGR;
   int end   = TradeEndHourGR*60   + TradeEndMinuteGR;

   return(cur >= start && cur <= end);
}

int TodayKeyGR()
{
   datetime grNow = GreeceTimeNow();
   // Unique key per day (YYYYMMDD)
   return(TimeYear(grNow)*10000 + TimeMonth(grNow)*100 + TimeDay(grNow));
}

bool IsOurOrder()
{
   return(OrderMagicNumber() == MagicNumber && OrderSymbol() == Symbol());
}

int CountTodayTradesClosed()
{
   int key = TodayKeyGR();
   int cnt = 0;

   for(int i=OrdersHistoryTotal()-1; i>=0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
      if(OrderMagicNumber() != MagicNumber) continue;
      if(OrderSymbol() != Symbol()) continue;

      datetime closeT = OrderCloseTime();
      // Convert close time to Greece time using same UTC logic:
      // Note: History time is server-based, but close time is datetime; we approximate via GMT offset.
      // For robust use, we focus on date in Greece by converting GMT.
      datetime closeGR = (closeT - (TimeCurrent() - TimeGMT())) + GR_UTC_Offset_Hours*3600;
      int closeKey = TimeYear(closeGR)*10000 + TimeMonth(closeGR)*100 + TimeDay(closeGR);

      if(closeKey == key) cnt++;
   }
   return(cnt);
}

int CountTodayLossTradesClosed()
{
   int key = TodayKeyGR();
   int cnt = 0;

   for(int i=OrdersHistoryTotal()-1; i>=0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
      if(OrderMagicNumber() != MagicNumber) continue;
      if(OrderSymbol() != Symbol()) continue;

      datetime closeT = OrderCloseTime();
      datetime closeGR = (closeT - (TimeCurrent() - TimeGMT())) + GR_UTC_Offset_Hours*3600;
      int closeKey = TimeYear(closeGR)*10000 + TimeMonth(closeGR)*100 + TimeDay(closeGR);

      if(closeKey != key) continue;

      double profit = OrderProfit() + OrderSwap() + OrderCommission();
      if(profit < 0) cnt++;
   }
   return(cnt);
}

int CountOpenPositions()
{
   int cnt = 0;
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(!IsOurOrder()) continue;
      if(OrderType() == OP_BUY || OrderType() == OP_SELL) cnt++;
   }
   return(cnt);
}

bool CanTradeNow()
{
   if(!IsInTradeWindow()) return(false);

   int closedToday = CountTodayTradesClosed();
   int lossToday   = CountTodayLossTradesClosed();
   if(closedToday >= MaxTradesPerDay) return(false);
   if(lossToday   >= MaxLossTradesPerDay) return(false);

   if(OneTradeAtATime && CountOpenPositions() > 0) return(false);

   return(true);
}

// Apply SL/TP management on existing positions
void ManageOpenTrades()
{
   double pip = PipValue();

   for(int i=OrdersTotal()-1; i>=0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(!IsOurOrder()) continue;

      int type = OrderType();
      if(type != OP_BUY && type != OP_SELL) continue;

      double entry = OrderOpenPrice();
      double sl    = OrderStopLoss();
      double tp    = OrderTakeProfit();

      // 1) Auto set SL/TP if missing
      if(AutoSetSLTP)
      {
         if(sl <= 0 || tp <= 0)
         {
            int slP = StopLossPips;
            double newSL = 0;
            double newTP = 0;

            if(type == OP_BUY)
            {
               newSL = entry - slP * pip;
               newTP = entry + (slP * RiskReward) * pip;
            }
            else
            {
               newSL = entry + slP * pip;
               newTP = entry - (slP * RiskReward) * pip;
            }

            // Only modify if values are valid
            bool ok = OrderModify(OrderTicket(), entry, newSL, newTP, 0, clrNONE);
            if(!ok) Print("OrderModify SL/TP failed: ", GetLastError());
            continue; // re-check next tick
         }
      }

      // 2) Break-even
      if(UseBreakEven)
      {
         double profitPips = 0;
         if(type == OP_BUY)  profitPips = (Bid - entry) / pip;
         if(type == OP_SELL) profitPips = (entry - Ask) / pip;

         if(profitPips >= BreakEvenAfterPips)
         {
            double beSL = entry;
            if(type == OP_BUY)  beSL = entry + BreakEvenBufferPips * pip;
            if(type == OP_SELL) beSL = entry - BreakEvenBufferPips * pip;

            // Move SL only in favorable direction
            bool shouldMove = false;
            if(type == OP_BUY && (sl < beSL)) shouldMove = true;
            if(type == OP_SELL && (sl > beSL || sl == 0)) shouldMove = true;

            if(shouldMove)
            {
               bool ok = OrderModify(OrderTicket(), entry, beSL, tp, 0, clrNONE);
               if(!ok) Print("OrderModify BE failed: ", GetLastError());
            }
         }
      }

      // 3) Trailing stop (simple)
      if(UseTrailing)
      {
         double profitPips = 0;
         if(type == OP_BUY)  profitPips = (Bid - entry) / pip;
         if(type == OP_SELL) profitPips = (entry - Ask) / pip;

         if(profitPips >= TrailStartPips)
         {
            double trailSL = sl;

            if(type == OP_BUY)
            {
               double desiredSL = Bid - TrailDistancePips * pip;
               if(desiredSL > sl) trailSL = desiredSL;
            }
            else
            {
               double desiredSL = Ask + TrailDistancePips * pip;
               if(sl == 0 || desiredSL < sl) trailSL = desiredSL;
            }

            if(trailSL != sl)
            {
               bool ok = OrderModify(OrderTicket(), entry, trailSL, tp, 0, clrNONE);
               if(!ok) Print("OrderModify Trail failed: ", GetLastError());
            }
         }
      }
   }
}

// ---------- MT4 events ----------
int OnInit()
{
   Print("EA Execution & Risk Manager v1 loaded. Symbol=", Symbol(), " Magic=", MagicNumber);
   return(INIT_SUCCEEDED);
}

void OnTick()
{
   // Always manage existing trades
   ManageOpenTrades();

   // Trading permissions (for manual entries guidance)
   // This EA does NOT open trades by itself in v1.
   // But we can display status in Experts log:
   static int lastKey = 0;
   int key = TodayKeyGR();
   if(key != lastKey)
   {
      lastKey = key;
      Print("New day (GR). ClosedToday=", CountTodayTradesClosed(), " LossToday=", CountTodayLossTradesClosed());
   }

   // Optional: warn if user tries to trade outside limits (informational)
   if(!CanTradeNow())
   {
      // keep quiet; you can uncomment to log periodically
      // Print("Trading blocked now (window/limits).");
   }
}