#include <Trade/Trade.mqh>
CTrade obj_Trade;

//+------------------------------------------------------------------+
//| Cup and Handle Multi-Timeframe EA with Auto-Trading and Logging  |
//+------------------------------------------------------------------+
#property copyright "xAI Grok Example"
#property link      "https://www.xai.com"
#property version   "1.00"

// Input parameters (aligned with your .set file)
input int look_back = 500;            // Lookback period (bars)
input int temp = 1;                   // Temporary variable (unused here)
input bool timeframe_scanner = true;  // Enable timeframe scanner
input string timeframeList = "M1,M5,M15,M30,H1,H4,D1,W1,MN1"; // Timeframes to scan
input bool i_shTlin = false;          // Show trend lines (unused here)
input color c_cup = 65535;            // Cup line color (cyan)
input color c_bord = 16776960;        // Border color (unused here)
input color cretr = 255;              // Retracement color (red)
input color c_text = 0;               // Text color (black)
input int text_size = 8;              // Text size
input string s1 = "__________| Alerts Sets |_________"; // Separator
input int alert_m = 2;                // Alert mode (2 = on pattern detection)
input double per = 30.0;              // Cup period in bars (replaces CupBars)
input int look_alert = 1;             // Lookback for alerts (1 = latest bar)
input bool Alerts = true;             // Enable alerts
input bool Push_alerts = false;       // Enable push notifications
input bool Email_alerts = false;      // Enable email alerts

// Trading inputs
input double LotSize = 0.1;           // Trade lot size
input double TP_Pips = 50;            // Take Profit in pips
input double SL_Pips = 20;            // Stop Loss in pips
input int MagicNumber = 12345;        // Unique trade identifier
input int HandleBars = 10;            // Bars for handle formation
input double MinCupDepth = 0.2;       // Minimum cup depth (as %)

// Global variables
datetime lastBarTime = 0;             // Tracks the last processed bar’s open time
ENUM_TIMEFRAMES tfArray[];

//+------------------------------------------------------------------+
//| Expert initialization function                                    |
//+------------------------------------------------------------------+
int OnInit()
{
   Print("Starting EA initialization...");
   string tfStrings[];
   int count = StringSplit(timeframeList, ',', tfStrings);
   ArrayResize(tfArray, count);
   for (int i = 0; i < count; i++)
   {
      tfArray[i] = StringToTimeframe(tfStrings[i]);
      Print("Parsed timeframe ", i + 1, ": ", EnumToString(tfArray[i]));
   }
   if (!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
   {
      Print("ERROR: Auto-trading is disabled in the terminal. Enable it to allow trades.");
      return(INIT_FAILED);
   }
   // Initialize lastBarTime to avoid missing the first bar
   lastBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
   Print("EA Initialized successfully | Magic Number: ", MagicNumber, " | Lookback: ", look_back, 
         " bars | Timeframes: ", count, " | Initial Last Bar Time: ", TimeToString(lastBarTime));
   return(INIT_SUCCEEDED);
}

long microseconds;  // Microsecond Timer

// Function to get microsecond timing
long GetMicroseconds() {
   return GetMicrosecondCount();
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   Print("Deinitializing EA | Reason: ", reason);
   ObjectsDeleteAll(0, "CupHandle_");
   Print("All chart objects deleted.");
}

ulong previousMicro = GetMicrosecondCount(); // Stores microseconds since program start

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

    ulong currentMicro = GetMicrosecondCount(); // Get current microseconds

   microseconds = GetMicroseconds();
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0); // Open time of latest complete bar
   datetime realTime = TimeCurrent(); // Real-time server time
   int totalBars = iBars(_Symbol, PERIOD_CURRENT); // Total bars available
   
   Print("Tick received | Current Bar Open Time: ", currentMicro, 
         " | Last Bar Time: ", previousMicro, 
         " | Real Server Time: ", TimeToString(realTime), 
         " | Total Bars: ", totalBars,"| PRD CURRENT",EnumToString(PERIOD_CURRENT));

   if (currentMicro == 0)
   {
      Print("ERROR: iTime returned 0, possibly no data available for ", _Symbol, " on ", EnumToString(PERIOD_CURRENT));
      return;
   }

   if (currentMicro <= previousMicro)
   {
      Print("No new bar detected | Current Bar Time: ", TimeToString(currentBarTime), 
            " is not newer than Last Bar Time: ", TimeToString(lastBarTime));
      return;
   }

   Print("New bar detected on ", _Symbol, " | Bar Open Time: ", TimeToString(currentBarTime));
   previousMicro = currentMicro; // Update lastBarTime only on new bar

   if (timeframe_scanner)
   {
      Print("Scanning multiple timeframes: ", ArraySize(tfArray), " total.");
      for (int tf = 0; tf < ArraySize(tfArray); tf++)
      {
         Print("Processing timeframe: ", EnumToString(tfArray[tf]));
         ScanTimeframe(tfArray[tf]);
      }
   }
   else
   {
      Print("Scanning only current timeframe: ", EnumToString(PERIOD_CURRENT));
      ScanTimeframe(PERIOD_CURRENT);
   }
}


//+------------------------------------------------------------------+
//| Convert string to timeframe                                      |
//+------------------------------------------------------------------+
ENUM_TIMEFRAMES StringToTimeframe(string tf)
{
   if (tf == "M1") return PERIOD_M1;
   if (tf == "M5") return PERIOD_M5;
   if (tf == "M15") return PERIOD_M15;
   if (tf == "M30") return PERIOD_M30;
   if (tf == "H1") return PERIOD_H1;
   if (tf == "H4") return PERIOD_H4;
   if (tf == "D1") return PERIOD_D1;
   if (tf == "W1") return PERIOD_W1;
   if (tf == "MN1") return PERIOD_MN1;
   Print("Unknown timeframe string '", tf, "', defaulting to PERIOD_CURRENT");
   return PERIOD_CURRENT;
}

//+------------------------------------------------------------------+
//| Scan a specific timeframe for patterns                           |
//+------------------------------------------------------------------+
void ScanTimeframe(ENUM_TIMEFRAMES timeframe)
{
   Print("Scanning ", _Symbol, " on ", EnumToString(timeframe), " with lookback: ", look_back);
   double high[], low[], close[];
   datetime time[];
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);
   ArraySetAsSeries(time, true);
   
   int barsToCopy = MathMin(look_back, iBars(_Symbol, timeframe));
   Print("Copying ", barsToCopy, " bars of data...");
   CopyHigh(_Symbol, timeframe, 0, barsToCopy, high);
   CopyLow(_Symbol, timeframe, 0, barsToCopy, low);
   CopyClose(_Symbol, timeframe, 0, barsToCopy, close);
   CopyTime(_Symbol, timeframe, 0, barsToCopy, time);

   if (ArraySize(high) < per + HandleBars + 1)
   {
      Print("Insufficient data: ", ArraySize(high), " bars available, need at least ", (int)per + HandleBars + 1);
      return;
   }
    Print("timeframe",EnumToString(timeframe));
    Print("PERIOD_CURRENT",EnumToString(PERIOD_CURRENT));

   //bool canTrade = (GetOpenPositionTicket() == 0 && EnumToString(timeframe) == EnumToString(PERIOD_CURRENT));
   bool canTrade = (GetOpenPositionTicket() == 0);
   Print("Can trade: ", canTrade, " | Open positions: ", (GetOpenPositionTicket() != 0 ? "Yes" : "No"), " | Timeframe match: ", (EnumToString(timeframe) == EnumToString(PERIOD_CURRENT) ? "Yes" : "No"));

   for (int i = (int)per + HandleBars; i < barsToCopy; i++)
   {
      //Print("Checking bar ", i, " for patterns...");
      CheckBullishPattern(timeframe, high, low, close, time, i, canTrade);
      CheckBearishPattern(timeframe, high, low, close, time, i, canTrade);
   }
}

//+------------------------------------------------------------------+
//| Check for Bullish Cup and Handle                                 |
//+------------------------------------------------------------------+
void CheckBullishPattern(ENUM_TIMEFRAMES timeframe, const double &high[], const double &low[], const double &close[], const datetime &time[], int shift, bool canTrade)
{
   int cupStart = shift - HandleBars - (int)per;
   int cupEnd = shift - HandleBars;
   
   double cupHigh1 = high[ArrayMaximum(high, cupStart, (int)per)];
   double cupLow = low[ArrayMinimum(low, cupStart, (int)per)];
   double cupHigh2 = high[ArrayMaximum(high, cupEnd, HandleBars)];
   double cupDepth = (cupHigh1 - cupLow) / cupHigh1;

  // Print(timeframe ,"Bullish check at shift ", shift, " | CupHigh1: ", cupHigh1, " | CupLow: ", cupLow, " | CupHigh2: ", cupHigh2, " | Depth: ", cupDepth," Condition "+cupDepth >= MinCupDepth && MathAbs(cupHigh1 - cupHigh2) < Point() * 20);

   if (cupDepth >= MinCupDepth && MathAbs(cupHigh1 - cupHigh2) < Point() * 20)
   {
      double handleHigh = high[ArrayMaximum(high, cupEnd, HandleBars)];
      double handleLow = low[ArrayMinimum(low, cupEnd, HandleBars)];
      double handleRange = handleHigh - handleLow;

      Print("Handle check | HandleHigh: ", handleHigh, " | HandleLow: ", handleLow, " | Range: ", handleRange);

      if (handleRange < (cupHigh1 - cupLow) * 0.4)
      {
         if (close[shift - 1] > handleHigh && close[shift] <= handleHigh)
         {
            string timeStr = TimeToString(time[shift]);
            Print("Bullish Cup and Handle detected at ", timeStr, " | Close[shift-1]: ", close[shift - 1], " | Close[shift]: ", close[shift]);
            if (Alerts && (shift <= look_alert || look_alert == 0))
            {
               string msg = "Bullish Cup and Handle on " + _Symbol + " TF: " + EnumToString(timeframe) + " at " + DoubleToString(close[shift - 1], 5);
               Print("Alert triggered: ", msg);
               Alert(msg);
               if (Push_alerts) SendNotification(msg);
               if (Email_alerts) SendMail("Cup and Handle Alert", msg);
            }
            if (EnumToString(timeframe) == EnumToString(PERIOD_CURRENT))
            {
               Print("Drawing Bullish pattern on chart...");
               DrawPattern("Bullish_" + timeStr, 
                           time[cupStart], cupHigh1, 
                           time[cupStart + ArrayMinimum(low, cupStart, (int)per)], cupLow, 
                           time[cupEnd], cupHigh2, 
                           time[shift - 1], handleHigh, c_cup, "Bullish Cup");
            }
            if (canTrade)
            {
               Print("Attempting to place Buy trade...");
               //PlaceBuyTrade(handleHigh);
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Check for Bearish Inverse Cup and Handle                         |
//+------------------------------------------------------------------+
void CheckBearishPattern(ENUM_TIMEFRAMES timeframe, const double &high[], const double &low[], const double &close[], const datetime &time[], int shift, bool canTrade)
{
   int cupStart = shift - HandleBars - (int)per;
   int cupEnd = shift - HandleBars;
   
   double cupLow1 = low[ArrayMinimum(low, cupStart, (int)per)];
   double cupHigh = high[ArrayMaximum(high, cupStart, (int)per)];
   double cupLow2 = low[ArrayMinimum(low, cupEnd, HandleBars)];
   double cupDepth = (cupHigh - cupLow1) / cupLow1;

   //Print("Bearish check at shift ", shift, " | CupLow1: ", cupLow1, " | CupHigh: ", cupHigh, " | CupLow2: ", cupLow2, " | Depth: ", cupDepth);

   if (cupDepth >= MinCupDepth && MathAbs(cupLow1 - cupLow2) < Point() * 20)
   {
      double handleHigh = high[ArrayMaximum(high, cupEnd, HandleBars)];
      double handleLow = low[ArrayMinimum(low, cupEnd, HandleBars)];
      double handleRange = handleHigh - handleLow;

      Print("Handle check | HandleHigh: ", handleHigh, " | HandleLow: ", handleLow, " | Range: ", handleRange);

      if (handleRange < (cupHigh - cupLow1) * 0.4)
      {
         if (close[shift - 1] < handleLow && close[shift] >= handleLow)
         {
            string timeStr = TimeToString(time[shift]);
            Print("Bearish Inverse Cup and Handle detected at ", timeStr, " | Close[shift-1]: ", close[shift - 1], " | Close[shift]: ", close[shift]);
            if (Alerts && (shift <= look_alert || look_alert == 0))
            {
               string msg = "Bearish Inverse Cup and Handle on " + _Symbol + " TF: " + EnumToString(timeframe) + " at " + DoubleToString(close[shift - 1], 5);
               Print("Alert triggered: ", msg);
               Alert(msg);
               if (Push_alerts) SendNotification(msg);
               if (Email_alerts) SendMail("Cup and Handle Alert", msg);
            }
            if (EnumToString(timeframe) == EnumToString(PERIOD_CURRENT))
            {
               Print("Drawing Bearish pattern on chart...");
               DrawPattern("Bearish_" + timeStr, 
                           time[cupStart], cupLow1, 
                           time[cupStart + ArrayMaximum(high, cupStart, (int)per)], cupHigh, 
                           time[cupEnd], cupLow2, 
                           time[shift - 1], handleLow, cretr, "Bearish Cup");
            }
            if (canTrade)
            {
               Print("Attempting to place Sell trade...");
               PlaceSellTrade(handleLow);
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Draw Cup and Handle pattern on chart with label                  |
//+------------------------------------------------------------------+
void DrawPattern(string name, datetime t1, double p1, datetime t2, double p2, datetime t3, double p3, datetime t4, double p4, color clr, string label)
{
   Print("Drawing pattern: ", name, " | Label: ", label);
   ObjectCreate(0, "CupHandle_" + name + "_CupLeft", OBJ_TREND, 0, t1, p1, t2, p2);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupLeft", OBJPROP_COLOR, clr);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupLeft", OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupLeft", OBJPROP_WIDTH, 2);
   
   ObjectCreate(0, "CupHandle_" + name + "_CupRight", OBJ_TREND, 0, t2, p2, t3, p3);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupRight", OBJPROP_COLOR, clr);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupRight", OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, "CupHandle_" + name + "_CupRight", OBJPROP_WIDTH, 2);
   
   ObjectCreate(0, "CupHandle_" + name + "_Handle", OBJ_TREND, 0, t3, p3, t4, p4);
   ObjectSetInteger(0, "CupHandle_" + name + "_Handle", OBJPROP_COLOR, clr);
   ObjectSetInteger(0, "CupHandle_" + name + "_Handle", OBJPROP_STYLE, STYLE_DASH);
   
   ObjectCreate(0, "CupHandle_" + name + "_Label", OBJ_TEXT, 0, t2, p2);
   ObjectSetString(0, "CupHandle_" + name + "_Label", OBJPROP_TEXT, label);
   ObjectSetInteger(0, "CupHandle_" + name + "_Label", OBJPROP_COLOR, c_text);
   ObjectSetInteger(0, "CupHandle_" + name + "_Label", OBJPROP_FONTSIZE, text_size);
   ObjectSetInteger(0, "CupHandle_" + name + "_Label", OBJPROP_ANCHOR, ANCHOR_CENTER);
   Print("Pattern drawn successfully.");
}

//+------------------------------------------------------------------+
//| Place a Buy trade                                                |
//+------------------------------------------------------------------+
void PlaceBuyTrade(double breakoutPrice)
{
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   double tp = ask + TP_Pips * point * 10;
   double sl = ask - SL_Pips * point * 10;

   Print("Placing Buy trade | Ask: ", ask, " | SL: ", sl, " | TP: ", tp, " | LotSize: ", LotSize);

   CTrade trade;
   trade.SetExpertMagicNumber(MagicNumber);
   if (trade.Buy(LotSize, _Symbol, ask, sl, tp, "Cup and Handle Buy"))
   {
      Print("Buy trade opened successfully at ", ask, " | TP: ", tp, " | SL: ", sl, " | Ticket: ", trade.ResultOrder());
   }
   else
   {
      int errorCode = GetLastError();
      Print("Failed to open Buy trade at ", ask, " | Error: ", errorCode, " - ", ErrorDescription(errorCode));
   }
}

//+------------------------------------------------------------------+
//| Place a Sell trade                                               |
//+------------------------------------------------------------------+
void PlaceSellTrade(double breakdownPrice)
{
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   double tp = bid - TP_Pips * point * 10;
   double sl = bid + SL_Pips * point * 10;

   Print("Placing Sell trade | Bid: ", bid, " | SL: ", sl, " | TP: ", tp, " | LotSize: ", LotSize);

   CTrade trade;
   trade.SetExpertMagicNumber(MagicNumber);
   if (trade.Sell(LotSize, _Symbol, bid, sl, tp, "Inverse Cup and Handle Sell"))
   {
      Print("Sell trade opened successfully at ", bid, " | TP: ", tp, " | SL: ", sl, " | Ticket: ", trade.ResultOrder());
   }
   else
   {
      int errorCode = GetLastError();
      Print("Failed to open Sell trade at ", bid, " | Error: ", errorCode, " - ", ErrorDescription(errorCode));
   }
}

//+------------------------------------------------------------------+
//| Check for open position                                          |
//+------------------------------------------------------------------+
ulong GetOpenPositionTicket()
{
   for (int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == MagicNumber)
      {
         ulong ticket = PositionGetTicket(i);
         Print("Open position found | Ticket: ", ticket);
         return ticket;
      }
   }
   Print("No open positions found for ", _Symbol, " with Magic Number: ", MagicNumber);
   return 0;
}

//+------------------------------------------------------------------+
//| Get error description (for better debugging)                     |
//+------------------------------------------------------------------+
string ErrorDescription(int errorCode)
{
   switch(errorCode)
   {
      case 10013: return "Invalid request";
      case 10014: return "Invalid volume";
      case 10015: return "Invalid price";
      case 10016: return "Invalid stops";
      case 10019: return "Not enough money";
      case 10021: return "Market is closed";
      default: return "Unknown error";
   }
}