// Version 3.7 (Fehlerbehebung: Bedingungslogik und Debugging-Ausgabe erweitert)
#property strict

input double Lots = 0.01; // Lot size
input int DistancePips = 10; // Distance in pips for new orders
input int ProfitTargetPips = 50; // Profit target in pips
input bool IsBuy = true; // Order type: true = Buy, false = Sell

bool levelActive[1000]; double lastOrderLevels[1000]; int orderCount = 0;

int OnInit() {
   ArrayInitialize(lastOrderLevels, 0.0); ArrayInitialize(levelActive, false);
   Print("EA initialized"); return(INIT_SUCCEEDED);
}

void OnTick() {
   RefreshRates(); // Update market prices

   double currentPrice = NormalizeDouble(IsBuy ? Ask : Bid, MarketInfo(Symbol(), MODE_DIGITS));
   double targetPrice = NormalizeDouble(MathFloor(currentPrice / ((double)DistancePips * Point)) * ((double)DistancePips * Point), MarketInfo(Symbol(), MODE_DIGITS));

   Print("[OnTick] Current Price: ", currentPrice, ", Target Price: ", targetPrice);

   bool exists = OrderExistsAtLevel(targetPrice);
   bool active = IsLevelActive(targetPrice);
   bool reactivatable = IsLevelReactivatable(targetPrice);

   Print("[OnTick] Order Exists: ", exists, ", Active: ", active, ", Reactivatable: ", reactivatable);

   // Bedingung gelockert, um mind. eine Order zu platzieren
   if (!exists && (!active || reactivatable)) {
      Print("[OnTick] Placing order at target price: ", targetPrice);
      if (PlaceOrder(targetPrice)) {
         AddOrUpdateLevel(targetPrice);
      }
   } else {
      Print("[OnTick] Skipping order placement for target price: ", targetPrice);
   }

   for (int i = 0; i < OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && OrderMagicNumber() == 12345) {
         double profitPips = (IsBuy ? Bid - OrderOpenPrice() : OrderOpenPrice() - Ask) / Point;
         if (profitPips >= ProfitTargetPips && OrderClose(OrderTicket(), OrderLots(), IsBuy ? Bid : Ask, 2, clrRed)) {
            Print("[OnTick] Order closed at price: ", OrderOpenPrice(), ", Profit Pips: ", profitPips);
            DeactivateLevel(OrderOpenPrice());
         }
      }
   }
}

bool PlaceOrder(double entryPrice) {
   RefreshRates(); // Ensure prices are up to date
   double price = NormalizeDouble(entryPrice, MarketInfo(Symbol(), MODE_DIGITS));
   int ticket = OrderSend(Symbol(), IsBuy ? OP_BUY : OP_SELL, Lots, price, 2, 0, 0, "Order", 12345, 0, clrGreen);
   if (ticket < 0) {
      Print("Order placement failed: ", ErrorDescription(GetLastError()));
      return false;
   }
   Print("Order placed successfully at price: ", price);
   return true;
}

void AddOrUpdateLevel(double level) {
   for (int i = 0; i < orderCount; i++) {
      if (fabs(lastOrderLevels[i] - level) < Point) {
         levelActive[i] = true; Print("[AddOrUpdateLevel] Reactivated level: ", level); return;
      }
   }
   lastOrderLevels[orderCount] = level; levelActive[orderCount++] = true;
   Print("[AddOrUpdateLevel] New level added: ", level);
}

void DeactivateLevel(double level) {
   for (int i = 0; i < orderCount; i++) {
      if (fabs(lastOrderLevels[i] - level) < Point) {
         levelActive[i] = false; Print("[DeactivateLevel] Deactivated level: ", level); return;
      }
   }
}

void ReactivateLevel(double level) {
   for (int i = 0; i < orderCount; i++) {
      if (fabs(lastOrderLevels[i] - level) < Point) {
         levelActive[i] = true; Print("[ReactivateLevel] Reactivated level: ", level); return;
      }
   }
   Print("[ReactivateLevel] Level not found for reactivation: ", level);
}

bool OrderExistsAtLevel(double level) {
   for (int i = 0; i < OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && fabs(OrderOpenPrice() - level) < Point) {
         Print("[OrderExistsAtLevel] Order exists at level: ", level);
         return true;
      }
   }
   return false;
}

bool IsLevelActive(double level) {
   int index = GetLevelIndex(level);
   if (index != -1 && levelActive[index]) {
      Print("[IsLevelActive] Level is active: ", level);
      return true;
   }
   return false;
}

bool IsLevelReactivatable(double level) {
   int index = GetLevelIndex(level);
   if (index != -1 && !levelActive[index]) {
      Print("[IsLevelReactivatable] Level is reactivatable: ", level);
      ReactivateLevel(level);
      return true;
   }
   return false;
}

int GetLevelIndex(double level) {
   for (int i = 0; i < orderCount; i++) {
      if (fabs(lastOrderLevels[i] - level) < Point) return i;
   }
   return -1;
}

string ErrorDescription(int errorCode) {
   switch(errorCode) {
      case 0: return("No error"); case 1: return("No connection");
      case 2: return("Common error"); case 3: return("Invalid trade parameters");
      case 4: return("Server is busy"); case 5: return("Old tick"); case 148: return("Invalid trade context");
      default: return("Unknown error");
   }
}