//+------------------------------------------------------------------+
//|                                                SignalGenerator.mqh |
//|                                          Copyright 2025, EscapeEA |
//|                                             https://www.escapeea.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, EscapeEA"
#property link      "https://www.escapeea.com"
#property version   "1.00"
#property strict

#include <Arrays\ArrayObj.mqh>
#include <Indicators\Trend.mqh>
#include <Indicators\Oscilators.mqh>

// Forward declarations
class CSymbolInfo;

//+------------------------------------------------------------------+
//| Signal types and enums                                           |
//+------------------------------------------------------------------+
enum ENUM_SIGNAL_TYPE {
   SIGNAL_TYPE_NONE = 0,      // No signal
   SIGNAL_TYPE_BUY = 1,       // Buy signal
   SIGNAL_TYPE_SELL = -1,     // Sell signal
   SIGNAL_TYPE_CLOSE = 2      // Close position signal
};

//+------------------------------------------------------------------+
//| Signal structure to hold signal details                          |
//+------------------------------------------------------------------+
struct SSignal {
   ENUM_SIGNAL_TYPE type;     // Signal type
   double           price;     // Entry price
   double           sl;        // Stop loss
   double           tp;        // Take profit
   double           strength;  // Signal strength (0.0 to 1.0)
   string           comment;   // Signal comment/description
   datetime         time;      // Signal time
   
   // Default constructor
   SSignal() {
      type = SIGNAL_TYPE_NONE;
      price = 0.0;
      sl = 0.0;
      tp = 0.0;
      strength = 0.0;
      comment = "";
      time = 0;
   }
};

//+------------------------------------------------------------------+
//| Signal Generator class                                           |
//+------------------------------------------------------------------+
class CSignalGenerator {
private:
   // Indicators
   CiMA             m_ma;              // Moving Average
   CiMA             m_maFast;          // Fast Moving Average
   CiMA             m_maSlow;          // Slow Moving Average
   CiATR            m_atr;             // Average True Range
   
   // Configuration
   int              m_maPeriod;        // MA Period
   int              m_maFastPeriod;    // Fast MA Period
   int              m_maSlowPeriod;    // Slow MA Period
   int              m_atrPeriod;       // ATR Period
   double           m_atrMultiplier;   // ATR Multiplier for SL/TP
   
   // State
   bool             m_initialized;     // Initialization flag
   CSymbolInfo     *m_symbol;          // Symbol info
   
   // Private methods
   bool             InitializeIndicators();
   double           CalculateATRMultiplier() const;
   
public:
   // Constructor/Destructor
                     CSignalGenerator();
                    ~CSignalGenerator();
   
   // Initialization
   bool              Initialize(CSymbolInfo *symbol, 
                              int maPeriod, 
                              int maFastPeriod, 
                              int maSlowPeriod, 
                              int atrPeriod, 
                              double atrMultiplier);
   
   // Signal generation
   bool              GenerateSignal(SSignal &signal);
   
   // Getters
   bool              IsInitialized() const { return m_initialized; }
   
   // Utility
   static string     SignalTypeToString(ENUM_SIGNAL_TYPE type);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSignalGenerator::CSignalGenerator() : 
   m_maPeriod(20),
   m_maFastPeriod(10),
   m_maSlowPeriod(50),
   m_atrPeriod(14),
   m_atrMultiplier(2.0),
   m_initialized(false),
   m_symbol(NULL)
{
   // Initialize indicators
   m_ma = CiMA();
   m_maFast = CiMA();
   m_maSlow = CiMA();
   m_atr = CiATR();
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSignalGenerator::~CSignalGenerator() {
   // Release indicators
   m_ma.Release();
   m_maFast.Release();
   m_maSlow.Release();
   m_atr.Release();
   
   // Clear symbol reference
   m_symbol = NULL;
   m_initialized = false;
}

//+------------------------------------------------------------------+
//| Initialize the signal generator                                  |
//+------------------------------------------------------------------+
bool CSignalGenerator::Initialize(CSymbolInfo *symbol, 
                                int maPeriod, 
                                int maFastPeriod, 
                                int maSlowPeriod, 
                                int atrPeriod, 
                                double atrMultiplier) {
   // Validate inputs
   if(symbol == NULL || !symbol.Name() == "") {
      Print("Error: Invalid symbol info");
      return false;
   }
   
   if(maPeriod <= 0 || maFastPeriod <= 0 || maSlowPeriod <= 0 || atrPeriod <= 0) {
      Print("Error: Invalid indicator periods");
      return false;
   }
   
   // Store configuration
   m_symbol = symbol;
   m_maPeriod = maPeriod;
   m_maFastPeriod = maFastPeriod;
   m_maSlowPeriod = maSlowPeriod;
   m_atrPeriod = atrPeriod;
   m_atrMultiplier = atrMultiplier;
   
   // Initialize indicators
   if(!InitializeIndicators()) {
      Print("Error: Failed to initialize indicators");
      return false;
   }
   
   m_initialized = true;
   return true;
}

//+------------------------------------------------------------------+
//| Initialize indicators                                            |
//+------------------------------------------------------------------+
bool CSignalGenerator::InitializeIndicators() {
   // Initialize MA
   if(!m_ma.Create(m_symbol.Name(), PERIOD_CURRENT, m_maPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
      Print("Error creating MA indicator");
      return false;
   }
   
   // Initialize Fast MA
   if(!m_maFast.Create(m_symbol.Name(), PERIOD_CURRENT, m_maFastPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
      Print("Error creating Fast MA indicator");
      return false;
   }
   
   // Initialize Slow MA
   if(!m_maSlow.Create(m_symbol.Name(), PERIOD_CURRENT, m_maSlowPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
      Print("Error creating Slow MA indicator");
      return false;
   }
   
   // Initialize ATR
   if(!m_atr.Create(m_symbol.Name(), PERIOD_CURRENT, m_atrPeriod)) {
      Print("Error creating ATR indicator");
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Generate trading signal                                          |
//+------------------------------------------------------------------+
bool CSignalGenerator::GenerateSignal(SSignal &signal) {
   // Reset signal
   signal = SSignal();
   
   // Check initialization
   if(!m_initialized || m_symbol == NULL) {
      signal.comment = "Signal generator not properly initialized";
      return false;
   }
   
   // Update symbol rates
   m_symbol.RefreshRates();
   
   // Get current prices
   double ask = m_symbol.Ask();
   double bid = m_symbol.Bid();
   double point = m_symbol.Point();
   int digits = (int)m_symbol.Digits();
   
   // Update indicators
   m_ma.Refresh(-1);
   m_maFast.Refresh(-1);
   m_maSlow.Refresh(-1);
   m_atr.Refresh(-1);
   
   // Get indicator values
   double ma[3], maFast[3], maSlow[3];
   
   if(m_ma.GetData(1, 1, 0, 3, ma) != 3 ||
      m_maFast.GetData(1, 1, 0, 3, maFast) != 3 ||
      m_maSlow.GetData(1, 1, 0, 3, maSlow) != 3) {
      signal.comment = "Failed to get indicator data";
      return false;
   }
   
   // Get ATR value for volatility
   double atr[1];
   if(m_atr.GetData(1, 1, 0, 1, atr) != 1) {
      signal.comment = "Failed to get ATR data";
      return false;
   }
   
   // Calculate signal strength (0.0 to 1.0)
   double strength = 0.0;
   
   // Check for trend direction
   bool uptrend = ma[0] > ma[1] && ma[1] > ma[2];
   bool downtrend = ma[0] < ma[1] && ma[1] < ma[2];
   
   // Check for MA cross
   bool fastAboveSlow = maFast[0] > maSlow[0] && maFast[1] <= maSlow[1];  // Bullish cross
   bool fastBelowSlow = maFast[0] < maSlow[0] && maFast[1] >= maSlow[1];  // Bearish cross
   
   // Generate signals based on strategy
   if(uptrend && fastAboveSlow) {
      // Strong buy signal
      signal.type = SIGNAL_TYPE_BUY;
      signal.price = ask;
      signal.strength = 0.8 + (MathRand() % 20) / 100.0; // 0.8-1.0
      signal.comment = "Strong buy: Uptrend with bullish MA cross";
   }
   else if(downtrend && fastBelowSlow) {
      // Strong sell signal
      signal.type = SIGNAL_TYPE_SELL;
      signal.price = bid;
      signal.strength = 0.8 + (MathRand() % 20) / 100.0; // 0.8-1.0
      signal.comment = "Strong sell: Downtrend with bearish MA cross";
   }
   else if(fastAboveSlow) {
      // Weak buy signal
      signal.type = SIGNAL_TYPE_BUY;
      signal.price = ask;
      signal.strength = 0.5 + (MathRand() % 30) / 100.0; // 0.5-0.8
      signal.comment = "Buy: Bullish MA cross";
   }
   else if(fastBelowSlow) {
      // Weak sell signal
      signal.type = SIGNAL_TYPE_SELL;
      signal.price = bid;
      signal.strength = 0.5 + (MathRand() % 30) / 100.0; // 0.5-0.8
      signal.comment = "Sell: Bearish MA cross";
   }
   
   // If we have a valid signal, calculate SL/TP
   if(signal.type != SIGNAL_TYPE_NONE) {
      double atrValue = atr[0];
      
      if(signal.type == SIGNAL_TYPE_BUY) {
         signal.sl = signal.price - (atrValue * m_atrMultiplier);
         signal.tp = signal.price + (atrValue * m_atrMultiplier * 1.5); // 1.5:1 reward:risk
      }
      else if(signal.type == SIGNAL_TYPE_SELL) {
         signal.sl = signal.price + (atrValue * m_atrMultiplier);
         signal.tp = signal.price - (atrValue * m_atrMultiplier * 1.5); // 1.5:1 reward:risk
      }
      
      // Normalize prices
      signal.sl = NormalizeDouble(signal.sl, digits);
      signal.tp = NormalizeDouble(signal.tp, digits);
      signal.time = TimeCurrent();
   }
   
   return (signal.type != SIGNAL_TYPE_NONE);
}

//+------------------------------------------------------------------+
//| Convert signal type to string                                    |
//+------------------------------------------------------------------+
string CSignalGenerator::SignalTypeToString(ENUM_SIGNAL_TYPE type) {
   switch(type) {
      case SIGNAL_TYPE_BUY:   return "BUY";
      case SIGNAL_TYPE_SELL:  return "SELL";
      case SIGNAL_TYPE_CLOSE: return "CLOSE";
      default:                return "NONE";
   }
}
//+------------------------------------------------------------------+