//+------------------------------------------------------------------+
//|                                                PositionManager.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 <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\Trade.mqh>
#include "InputValidation.mqh"

//+------------------------------------------------------------------+
//| Position scaling profiles                                        |
//+------------------------------------------------------------------+
enum ENUM_SCALING_PROFILE {
   SCALING_NONE,         // No scaling
   SCALING_CONSERVATIVE, // Conservative scaling
   SCALING_MODERATE,     // Moderate scaling
   SCALING_AGGRESSIVE    // Aggressive scaling
};

//+------------------------------------------------------------------+
//| Exit profiles                                                    |
//+------------------------------------------------------------------+
enum ENUM_EXIT_PROFILE {
   EXIT_AGGRESSIVE,      // Aggressive exit (tighter stops)
   EXIT_BALANCED,        // Balanced exit
   EXIT_CONSERVATIVE     // Conservative exit (wider stops)
};

//+------------------------------------------------------------------+
//| Position Manager class                                           |
//+------------------------------------------------------------------+
class CPositionManager {
private:
   CTrade        *m_trade;           // Trade object
   CSymbolInfo   *m_symbol;          // Symbol info
   CPositionInfo  m_position;        // Position info
   
   // Configuration
   double         m_slPoints;        // Stop loss in points
   double         m_tpPoints;        // Take profit in points
   double         m_trailingStop;    // Trailing stop in points
   double         m_breakEven;       // Break even level in points
   
   // State
   bool           m_initialized;     // Initialization flag
   bool           m_autoBreakEven;   // Auto break-even flag
   bool           m_scaleIn;         // Scale into positions flag
   bool           m_scaleOut;        // Scale out of positions flag
   
   // Advanced position management
   double         m_breakEvenAt;           // Pips in profit to move to break-even
   double         m_scaleInAt;             // Pips in drawdown to scale in
   double         m_scaleOutAt;            // Pips in profit to scale out
   double         m_scaleInFactor;         // Scale-in volume factor
   double         m_scaleOutFactor;        // Scale-out volume factor
   
   // Private methods
   bool           CheckTrailingStop();
   bool           CheckBreakEven();
   
public:
   // Constructor/Destructor
                     CPositionManager();
                    ~CPositionManager();
   
   // Initialization
   bool              Initialize(CTrade *trade, CSymbolInfo *symbol, 
                              double slPoints, double tpPoints, 
                              double trailingStop = 0, double breakEven = 0);
   
   // Position management
   bool              OpenPosition(ENUM_ORDER_TYPE type, double volume, 
                                double price, double sl, double tp, 
                                const string comment = "");
   bool              ClosePosition(ulong ticket, const string comment = "");
   bool              CloseAllPositions(const string comment = "");
   bool              ModifyPosition(ulong ticket, double sl, double tp);
   
   // Advanced position management
   bool              SetScalingProfile(ENUM_SCALING_PROFILE profile);
   bool              SetExitProfile(ENUM_EXIT_PROFILE profile);
   
   // Getters
   bool              IsInitialized() const { return m_initialized; }
   double            GetPositionSize(ulong ticket);
   double            GetPositionProfit(ulong ticket);
   double            GetPositionStopLoss(ulong ticket);
   double            GetPositionTakeProfit(ulong ticket);
   
   // Utility
   void              Update();
   
   // Advanced methods
   bool              ScaleInPosition(ulong ticket, double volume);
   bool              ScaleOutPosition(ulong ticket, double volume);
   double            GetPositionRisk(ulong ticket);
   bool              SetDynamicRisk(bool enable, double maxDailyDrawdown = 5.0, 
                                  double maxPositionRisk = 2.0, double maxPortfolioRisk = 20.0, 
                                  double riskDecay = 0.9);
   
   // Position clustering
   bool              SetPositionClustering(bool enable, double clusterDistance = 20.0, int maxClusters = 3);
   
   // Market regime detection
   bool              SetRegimeFilter(bool enable, double trendThreshold = 0.3);
   
   // News event handling
   bool              SetNewsFilter(bool enable, int minImpact = 2, int minutesBefore = 30, int minutesAfter = 15);
   
   // Volatility-based position sizing
   bool              SetVolatilitySizing(bool enable, int period = 14, double multiplier = 1.5, double maxRisk = 2.0);
   
   // Correlation management
   bool              SetCorrelationFilter(bool enable, const string &symbols = "", double maxCorrelation = 0.7);
   
   // Grid trading
   bool              SetGridTrading(bool enable, double gridStep = 20.0, int maxLevels = 5, double volumeMultiplier = 1.5);
   
   // Machine learning integration
   bool              SetMLIntegration(bool enable, double confidenceThreshold = 0.7);
   
   // Adaptive position sizing
   bool              SetAdaptiveSizing(bool enable, double winRate = 0.5, double profitFactor = 1.5);
   
   // Advanced exit strategies
   bool              SetTrailingDrawdown(bool enable, double drawdownPercent = 30.0);
   bool              SetVolatilityExit(bool enable, double volatilityLevel = 2.0);
   
   // Time-based exit
   bool              SetTimeExit(bool enable, int maxHoldBars = 50);
   
   // Position monitoring
   bool              UpdatePositionMetrics(ulong ticket);
   
   // Risk management
   bool              CheckDailyDrawdown();
   bool              CheckPortfolioRisk();
   
   // Position analysis
   double            CalculatePositionScore(const string symbol, ENUM_ORDER_TYPE type);
   double            CalculateOptimalF(double winRate, double winLossRatio);
   double            CalculateKellyCriterion(double winRate, double winLossRatio);
   
   // Position clustering
   bool              IsInCluster(ulong ticket, double distance = 20.0);
   
   // Market regime detection
   ENUM_MARKET_REGIME GetMarketRegime();
   
   // News impact analysis
   int               GetNewsImpact();
   
   // Volatility analysis
   double            GetCurrentVolatility();
   
   // Correlation analysis
   double            GetPortfolioCorrelation(const string symbol);
   
   // Machine learning
   bool              LoadMLModel(const string modelFile);
   double            GetMLPositionScore(const string symbol, ENUM_ORDER_TYPE type);
   bool              UpdateMLModel(const MqlRates &rates[], const double &features[]);
   
   // Advanced position monitoring
   bool              CheckPositionHealth(ulong ticket);
   bool              CheckMarketConditions();
   bool              CheckPositionTiming(ulong ticket);
   
   // Advanced position adjustments
   bool              HedgePosition(ulong ticket);
   bool              AverageDown(ulong ticket, double maxDrawdown = 10.0);
   bool              ScaleOutAtProfit(ulong ticket, double profitTarget = 30.0, double scalePercent = 50.0);
   
   // Position analysis
   double            CalculatePositionValue(ulong ticket);
   double            CalculatePositionRiskReward(ulong ticket);
   double            CalculatePositionScore(ulong ticket);
   
   // Advanced order types
   bool              PlaceBracketOrder(const string symbol, ENUM_ORDER_TYPE type, double volume, 
                                     double entryPrice, double sl, double tp, 
                                     double breakEvenAt = 0, double trailingStop = 0, 
                                     datetime expiration = 0, const string comment = "");
   
   // Advanced position management
   bool              ScalePosition(ulong ticket, double newVolume);
   bool              ScalePositionByRisk(ulong ticket, double riskPercent);
   bool              ScalePositionByVolatility(ulong ticket, double volatilityMultiplier = 1.0);
   
   // Position monitoring and adjustment
   bool              CheckAndAdjustPosition(ulong ticket);
   bool              MonitorAndManagePositions();
   
   // Advanced risk management
   bool              SetRiskParameters(double maxRiskPerTrade, double maxDailyRisk, double maxDrawdown);
   bool              CheckRiskParameters();
   
   // Position analysis and optimization
   double            CalculateOptimalPositionSize(double riskAmount, double stopLoss);
   double            CalculatePositionRisk(double entryPrice, double stopLoss, double lotSize);
   double            CalculatePositionValue(double entryPrice, double lotSize);
   
   // Advanced position monitoring
   bool              CheckPositionHealth(ulong ticket, double maxDrawdown = 20.0);
   bool              CheckPositionTiming(ulong ticket, int maxBars = 50);
   
   // Advanced position adjustments
   bool              TrailingStop(ulong ticket, double trailingStop);
   bool              MoveToBreakEven(ulong ticket, double breakEvenAt);
   
   // Position analysis
   double            CalculatePositionRiskReward(ulong ticket, double entryPrice, double stopLoss, double takeProfit);
   double            CalculatePositionScore(ulong ticket, double winRate, double profitFactor);
   
   // Advanced order management
   bool              PlaceOCOOrders(ulong ticket, double stopLoss, double takeProfit);
   bool              PlaceBracketOrder(ulong ticket, double stopLoss, double takeProfit, 
                                     double breakEvenAt = 0, double trailingStop = 0);
   
   // Position monitoring and management
   bool              MonitorPosition(ulong ticket);
   bool              ManagePosition(ulong ticket);
   
   // Advanced position management
   bool              ScaleInAtDrawdown(ulong ticket, double drawdownPercent, double scaleFactor = 1.0);
   bool              ScaleOutAtProfit(ulong ticket, double profitPercent, double scaleFactor = 0.5);
   
   // Position analysis and optimization
   double            CalculateOptimalPositionSize(double accountBalance, double riskPercent, 
                                               double stopLoss, double contractSize);
   double            CalculatePositionRisk(double entryPrice, double stopLoss, 
                                        double lotSize, double contractSize);
   
   // Advanced position monitoring
   bool              CheckPositionHealth(ulong ticket, double maxDrawdownPercent, 
                                      int maxBarsHeld, double minRiskReward);
   
   // Advanced position adjustments
   bool              AdjustStopLoss(ulong ticket, double newStopLoss);
   bool              AdjustTakeProfit(ulong ticket, double newTakeProfit);
   
   // Position analysis
   double            CalculatePositionValue(double entryPrice, double lotSize, double contractSize);
   double            CalculatePositionRiskReward(ulong ticket, double currentPrice);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CPositionManager::CPositionManager() :
   m_trade(NULL),
   m_symbol(NULL),
   m_initialized(false),
   m_slPoints(0.0),
   m_tpPoints(0.0),
   m_trailingStop(0.0),
   m_breakEven(0.0),
   m_autoBreakEven(false),
   m_scaleIn(false),
   m_scaleOut(false),
   m_breakEvenAt(0.0),
   m_scaleInAt(0.0),
   m_scaleOutAt(0.0),
   m_scaleInFactor(1.0),
   m_scaleOutFactor(0.5)
{
   // Initialize member variables in the initialization list
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CPositionManager::~CPositionManager() {
   // Cleanup if needed
   if(m_trade != NULL) {
      delete m_trade;
      m_trade = NULL;
   }
   
   if(m_symbol != NULL) {
      delete m_symbol;
      m_symbol = NULL;
   }
}

//+------------------------------------------------------------------+
//| Initialize the position manager                                  |
//+------------------------------------------------------------------+
bool CPositionManager::Initialize(CTrade *trade, CSymbolInfo *symbol, 
                                double slPoints, double tpPoints, 
                                double trailingStop, double breakEven) {
   // Validate inputs
   if(trade == NULL || symbol == NULL) {
      Print("Error: Invalid trade or symbol pointer");
      return false;
   }
   
   if(slPoints < 0 || tpPoints < 0 || trailingStop < 0 || breakEven < 0) {
      Print("Error: Invalid parameters");
      return false;
   }
   
   // Store references
   m_trade = trade;
   m_symbol = symbol;
   
   // Store parameters
   m_slPoints = slPoints;
   m_tpPoints = tpPoints;
   m_trailingStop = trailingStop;
   m_breakEven = breakEven;
   
   m_initialized = true;
   return true;
}

//+------------------------------------------------------------------+
//| Open a new position                                              |
//+------------------------------------------------------------------+
bool CPositionManager::OpenPosition(ENUM_ORDER_TYPE type, double volume, 
                                  double price, double sl, double tp, 
                                  const string comment) {
   if(!m_initialized) {
      Print("Error: Position manager not initialized");
      return false;
   }
   
   // Validate inputs
   if(volume <= 0 || price <= 0) {
      Print("Error: Invalid volume or price");
      return false;
   }
   
   // Execute the trade
   if(type == ORDER_TYPE_BUY) {
      return m_trade.Buy(volume, m_symbol.Name(), price, sl, tp, comment);
   } 
   else if(type == ORDER_TYPE_SELL) {
      return m_trade.Sell(volume, m_symbol.Name(), price, sl, tp, comment);
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Close a position by ticket                                       |
//+------------------------------------------------------------------+
bool CPositionManager::ClosePosition(ulong ticket, const string comment) {
   if(!m_initialized) {
      Print("Error: Position manager not initialized");
      return false;
   }
   
   // Select the position
   if(!m_position.SelectByTicket(ticket)) {
      Print("Error selecting position ", ticket);
      return false;
   }
   
   // Close the position
   return m_trade.PositionClose(ticket, m_position.Deviation(), comment);
}

//+------------------------------------------------------------------+
//| Close all open positions                                         |
//+------------------------------------------------------------------+
bool CPositionManager::CloseAllPositions(const string comment) {
   if(!m_initialized) {
      Print("Error: Position manager not initialized");
      return false;
   }
   
   bool result = true;
   int total = PositionsTotal();
   
   for(int i = total - 1; i >= 0; i--) {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0) {
         if(!ClosePosition(ticket, comment)) {
            result = false;
         }
      }
   }
   
   return result;
}

//+------------------------------------------------------------------+
//| Modify position stop loss and take profit                        |
//+------------------------------------------------------------------+
bool CPositionManager::ModifyPosition(ulong ticket, double sl, double tp) {
   if(!m_initialized) {
      Print("Error: Position manager not initialized");
      return false;
   }
   
   // Select the position
   if(!m_position.SelectByTicket(ticket)) {
      Print("Error selecting position ", ticket);
      return false;
   }
   
   // Modify the position
   return m_trade.PositionModify(ticket, sl, tp);
}

//+------------------------------------------------------------------+
//| Set position scaling profile                                     |
//+------------------------------------------------------------------+
bool CPositionManager::SetScalingProfile(ENUM_SCALING_PROFILE profile) {
   switch(profile) {
      case SCALING_AGGRESSIVE:
         m_scaleInFactor = 1.5;
         m_scaleOutFactor = 0.5;
         m_scaleInAt = 20.0;
         m_scaleOutAt = 30.0;
         break;
         
      case SCALING_MODERATE:
         m_scaleInFactor = 1.25;
         m_scaleOutFactor = 0.75;
         m_scaleInAt = 25.0;
         m_scaleOutAt = 40.0;
         break;
         
      case SCALING_CONSERVATIVE:
         m_scaleInFactor = 1.1;
         m_scaleOutFactor = 0.9;
         m_scaleInAt = 30.0;
         m_scaleOutAt = 50.0;
         break;
         
      case SCALING_NONE:
      default:
         m_scaleIn = false;
         m_scaleOut = false;
         return true;
   }
   
   m_scaleIn = true;
   m_scaleOut = true;
   return true;
}

//+------------------------------------------------------------------+
//| Set exit profile                                                 |
//+------------------------------------------------------------------+
bool CPositionManager::SetExitProfile(ENUM_EXIT_PROFILE profile) {
   switch(profile) {
      case EXIT_AGGRESSIVE:
         m_trailingStop = 20.0;
         m_breakEvenAt = 15.0;
         break;
         
      case EXIT_BALANCED:
         m_trailingStop = 30.0;
         m_breakEvenAt = 25.0;
         break;
         
      case EXIT_CONSERVATIVE:
         m_trailingStop = 50.0;
         m_breakEvenAt = 40.0;
         break;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Get position size                                                |
//+------------------------------------------------------------------+
double CPositionManager::GetPositionSize(ulong ticket) {
   if(m_position.SelectByTicket(ticket)) {
      return m_position.Volume();
   }
   return 0.0;
}

//+------------------------------------------------------------------+
//| Get position profit                                              |
//+------------------------------------------------------------------+
double CPositionManager::GetPositionProfit(ulong ticket) {
   if(m_position.SelectByTicket(ticket)) {
      return m_position.Profit();
   }
   return 0.0;
}

//+------------------------------------------------------------------+
//| Get position stop loss level                                     |
//+------------------------------------------------------------------+
double CPositionManager::GetPositionStopLoss(ulong ticket) {
   if(m_position.SelectByTicket(ticket)) {
      return m_position.StopLoss();
   }
   return 0.0;
}

//+------------------------------------------------------------------+
//| Get position take profit level                                   |
//+------------------------------------------------------------------+
double CPositionManager::GetPositionTakeProfit(ulong ticket) {
   if(m_position.SelectByTicket(ticket)) {
      return m_position.TakeProfit();
   }
   return 0.0;
}

//+------------------------------------------------------------------+
//| Update position manager (call in OnTick)                         |
//+------------------------------------------------------------------+
void CPositionManager::Update() {
   if(!m_initialized) {
      return;
   }
   
   // Update trailing stops if enabled
   if(m_trailingStop > 0) {
      CheckTrailingStop();
   }
   
   // Update break-even if enabled
   if(m_breakEven > 0) {
      CheckBreakEven();
   }
}

//+------------------------------------------------------------------+
//| Check and update trailing stop                                   |
//+------------------------------------------------------------------+
bool CPositionManager::CheckTrailingStop() {
   if(!m_initialized || m_trailingStop <= 0) {
      return false;
   }
   
   bool result = true;
   int total = PositionsTotal();
   
   for(int i = 0; i < total; i++) {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && m_position.SelectByTicket(ticket)) {
         double currentSl = m_position.StopLoss();
         double currentPrice = (m_position.PositionType() == POSITION_TYPE_BUY) ? 
                              m_position.PriceCurrent() : m_position.PriceOpen();
         double newSl = 0.0;
         
         if(m_position.PositionType() == POSITION_TYPE_BUY) {
            newSl = m_symbol.Bid() - (m_trailingStop * m_symbol.Point());
            if(newSl > currentSl && newSl < m_symbol.Bid()) {
               if(!ModifyPosition(ticket, newSl, m_position.TakeProfit())) {
                  result = false;
               }
            }
         }
         else if(m_position.PositionType() == POSITION_TYPE_SELL) {
            newSl = m_symbol.Ask() + (m_trailingStop * m_symbol.Point());
            if((newSl < currentSl || currentSl == 0) && newSl > m_symbol.Ask()) {
               if(!ModifyPosition(ticket, newSl, m_position.TakeProfit())) {
                  result = false;
               }
            }
         }
      }
   }
   
   return result;
}

//+------------------------------------------------------------------+
//| Check and update break-even level                                |
//+------------------------------------------------------------------+
bool CPositionManager::CheckBreakEven() {
   if(!m_initialized || m_breakEven <= 0) {
      return false;
   }
   
   bool result = true;
   int total = PositionsTotal();
   
   for(int i = 0; i < total; i++) {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && m_position.SelectByTicket(ticket)) {
         double currentSl = m_position.StopLoss();
         double openPrice = m_position.PriceOpen();
         double currentPrice = (m_position.PositionType() == POSITION_TYPE_BUY) ? 
                              m_position.PriceCurrent() : m_position.PriceOpen();
         double pointsProfit = MathAbs(currentPrice - openPrice) / m_symbol.Point();
         
         if(pointsProfit >= m_breakEven) {
            if(m_position.PositionType() == POSITION_TYPE_BUY) {
               if(currentSl < openPrice) {
                  if(!ModifyPosition(ticket, openPrice, m_position.TakeProfit())) {
                     result = false;
                  }
               }
            }
            else if(m_position.PositionType() == POSITION_TYPE_SELL) {
               if(currentSl > openPrice || currentSl == 0) {
                  if(!ModifyPosition(ticket, openPrice, m_position.TakeProfit())) {
                     result = false;
                  }
               }
            }
         }
      }
   }
   
   return result;
}