# MT5 Sniper EA - API Documentation

## Table of Contents

1. [Core Classes](#core-classes)
2. [Market Structure Analysis](#market-structure-analysis)
3. [Risk Management](#risk-management)
4. [Session Management](#session-management)
5. [AI Integration](#ai-integration)
6. [Backtesting Framework](#backtesting-framework)
7. [Visualization System](#visualization-system)
8. [Utility Classes](#utility-classes)
9. [Data Structures](#data-structures)
10. [Enumerations](#enumerations)

---

## Core Classes

### CLogger

**File**: `Include/Utils/Logger.mqh`

Centralized logging system for the EA with multiple log levels and output options.

#### Methods

```mql5
class CLogger
{
public:
    // Initialization
    bool Initialize(string filename, ENUM_LOG_LEVEL level = LOG_LEVEL_INFO);
    void Deinitialize();

    // Logging methods
    void LogError(string message, string function = "", int line = 0);
    void LogWarning(string message, string function = "", int line = 0);
    void LogInfo(string message, string function = "", int line = 0);
    void LogDebug(string message, string function = "", int line = 0);
    void LogTrace(string message, string function = "", int line = 0);

    // Configuration
    void SetLogLevel(ENUM_LOG_LEVEL level);
    void SetConsoleOutput(bool enable);
    void SetFileOutput(bool enable);
    void SetMaxFileSize(long max_size_mb);

    // Utility
    void Flush();
    string GetLogFilePath();
    long GetLogFileSize();
};
```

#### Usage Example

```mql5
CLogger logger;
logger.Initialize("SniperEA.log", LOG_LEVEL_DEBUG);
logger.LogInfo("EA initialized successfully");
logger.LogError("Failed to place order", __FUNCTION__, __LINE__);
```

---

## Market Structure Analysis

### COrderBlockDetector

**File**: `Include/MarketStructure/OrderBlock.mqh`

Detects and manages institutional order blocks using price action analysis.

#### Key Methods

```mql5
class COrderBlockDetector
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void SetParameters(int min_size, int max_age, int confirmation_bars);

    // Detection
    bool DetectOrderBlocks();
    bool IsOrderBlockValid(const SOrderBlock &block);
    bool IsOrderBlockActive(const SOrderBlock &block);

    // Analysis
    SOrderBlock* GetNearestOrderBlock(double price, ENUM_ORDER_BLOCK_TYPE type);
    int GetOrderBlockCount(ENUM_ORDER_BLOCK_TYPE type = ORDER_BLOCK_ALL);
    double GetOrderBlockStrength(const SOrderBlock &block);

    // Management
    void UpdateOrderBlocks();
    void CleanupExpiredBlocks();
    void ClearAllBlocks();

    // Visualization
    void DrawOrderBlocks();
    void RemoveOrderBlockObjects();
};
```

#### SOrderBlock Structure

```mql5
struct SOrderBlock
{
    datetime time;                    // Formation time
    double high;                      // Block high price
    double low;                       // Block low price
    ENUM_ORDER_BLOCK_TYPE type;       // Block type (bullish/bearish)
    double strength;                  // Block strength (0.0-1.0)
    int touches;                      // Number of touches
    bool is_active;                   // Active status
    bool is_broken;                   // Broken status
    datetime last_test_time;          // Last test time
    string id;                        // Unique identifier
};
```

### CBreakOfStructureDetector

**File**: `Include/MarketStructure/BreakOfStructure.mqh`

Identifies market structure breaks and trend changes using swing point analysis.

#### Key Methods

```mql5
class CBreakOfStructureDetector
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void SetParameters(int min_break_size, ENUM_BOS_CONFIRMATION_METHOD method);

    // Detection
    bool DetectBreakOfStructure();
    bool IsValidBOS(const SBOS &bos);
    bool ConfirmBOS(const SBOS &bos);

    // Analysis
    SBOS* GetLatestBOS(ENUM_BOS_TYPE type = BOS_TYPE_ALL);
    bool IsStructureBroken(double level, ENUM_BOS_TYPE type);
    double GetBOSStrength(const SBOS &bos);

    // Swing Points
    bool DetectSwingPoints();
    SSwingPoint* GetSwingHigh(int index = 0);
    SSwingPoint* GetSwingLow(int index = 0);

    // Visualization
    void DrawBOS();
    void DrawSwingPoints();
};
```

### CLiquiditySweepDetector

**File**: `Include/MarketStructure/LiquiditySweep.mqh`

Detects liquidity sweeps and stop hunts in the market.

#### Key Methods

```mql5
class CLiquiditySweepDetector
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void SetParameters(double sensitivity, double min_strength);

    // Detection
    bool DetectLiquidityZones();
    bool CheckForSweep();
    bool IsValidSweep(const SLiquiditySweep &sweep);

    // Analysis
    double CalculateSweepStrength(const SLiquiditySweep &sweep);
    SLiquidityZone* GetNearestLiquidityZone(double price);
    bool IsLiquidityGrabbed(const SLiquidityZone &zone);

    // Management
    void UpdateLiquidityZones();
    void CleanupOldSweeps();

    // Visualization
    void DrawLiquidityZones();
    void DrawSweeps();
};
```

### CFairValueGapDetector

**File**: `Include/MarketStructure/FairValueGap.mqh`

Identifies and manages Fair Value Gaps (imbalance zones) in price action.

#### Key Methods

```mql5
class CFairValueGapDetector
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void SetParameters(int min_size, int max_age, bool require_confirmation);

    // Detection
    bool DetectFairValueGaps();
    bool IsValidFVG(const SFairValueGap &fvg);
    bool IsFVGFilled(const SFairValueGap &fvg);

    // Analysis
    SFairValueGap* GetNearestFVG(double price, ENUM_FVG_TYPE type);
    double GetFVGFillPercentage(const SFairValueGap &fvg);
    bool IsFVGActive(const SFairValueGap &fvg);

    // Management
    void UpdateFVGStatus();
    void CleanupFilledFVGs();

    // Visualization
    void DrawFairValueGaps();
    void UpdateFVGDisplay();
};
```

### CEntryStrategy

**File**: `Include/MarketStructure/EntryStrategy.mqh`

Combines all market structure components to generate entry signals.

#### Key Methods

```mql5
class CEntryStrategy
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void ConfigureDetectors();
    void SetRequirements(bool require_ob, bool require_bos, bool require_ls, bool require_fvg);

    // Analysis
    SEntrySignal AnalyzeEntry();
    bool ValidateSignal(const SEntrySignal &signal);
    double CalculateSignalStrength(const SEntrySignal &signal);

    // Signal Management
    bool IsSignalValid(const SEntrySignal &signal);
    void UpdateSignalStatus();
    void ClearExpiredSignals();

    // Integration
    void SetOrderBlockDetector(COrderBlockDetector* detector);
    void SetBOSDetector(CBreakOfStructureDetector* detector);
    void SetLiquiditySweepDetector(CLiquiditySweepDetector* detector);
    void SetFVGDetector(CFairValueGapDetector* detector);
};
```

---

## Risk Management

### CRiskManager

**File**: `Include/RiskManagement/RiskManager.mqh`

Comprehensive risk management system handling position sizing, stop losses, and portfolio risk.

#### Key Methods

```mql5
class CRiskManager
{
public:
    // Initialization
    bool Initialize(string symbol);
    void SetRiskProfile(const SRiskProfile &profile);
    void SetAccountInfo(double balance, double equity, double margin);

    // Position Sizing
    double CalculatePositionSize(double entry_price, double stop_loss, double risk_amount);
    double CalculateRiskAmount(double risk_percent);
    bool ValidatePositionSize(double lot_size);

    // Stop Loss & Take Profit
    double CalculateStopLoss(double entry_price, ENUM_ORDER_TYPE order_type, ENUM_SL_METHOD method);
    double CalculateTakeProfit(double entry_price, double stop_loss, ENUM_TP_METHOD method);
    double CalculateTrailingStop(double current_price, double entry_price, ENUM_ORDER_TYPE order_type);

    // Risk Validation
    bool ValidateRisk(double entry_price, double stop_loss, double lot_size);
    bool CheckAccountRisk();
    bool CheckDrawdownLimit();
    bool CheckDailyLossLimit();

    // Position Management
    bool UpdatePosition(const SPositionInfo &position);
    void CalculateUnrealizedPnL();
    void UpdateRiskMetrics();

    // Emergency Controls
    bool TriggerEmergencyStop();
    void CloseAllPositions();
    void ReducePositionSizes(double reduction_factor);

    // Reporting
    SRiskStats GetRiskStatistics();
    double GetCurrentDrawdown();
    double GetMaxDrawdown();
    double GetSharpeRatio();
    double GetSortinoRatio();
};
```

#### SRiskProfile Structure

```mql5
struct SRiskProfile
{
    ENUM_RISK_MODEL risk_model;          // Risk model type
    double risk_percent;                 // Risk per trade (%)
    double max_risk_percent;             // Maximum account risk (%)
    double min_position_size;            // Minimum lot size
    double max_position_size;            // Maximum lot size
    ENUM_SL_METHOD sl_method;            // Stop loss method
    ENUM_TP_METHOD tp_method;            // Take profit method
    double sl_atr_multiplier;            // SL ATR multiplier
    double tp_rr_ratio;                  // Take profit risk-reward ratio
    bool use_trailing_stop;              // Enable trailing stop
    double trailing_atr_multiplier;      // Trailing stop ATR multiplier
    double max_drawdown_percent;         // Maximum drawdown limit
    double daily_loss_limit;             // Daily loss limit (%)
    bool use_time_stop;                  // Enable time-based stop
    int max_trade_duration_hours;        // Maximum trade duration
};
```

---

## Session Management

### CSessionManager

**File**: `Include/SessionManagement/SessionManager.mqh`

Manages trading sessions and time-based filters for optimal trade timing.

#### Key Methods

```mql5
class CSessionManager
{
public:
    // Initialization
    bool Initialize();
    void SetSessionConfig(const SSessionConfig &config);
    void SetTimeZone(int gmt_offset);

    // Session Analysis
    ENUM_TRADING_SESSION GetCurrentSession();
    ENUM_SESSION_PHASE GetSessionPhase();
    bool IsSessionActive(ENUM_TRADING_SESSION session);
    bool IsTradingAllowed();

    // Session Statistics
    SSessionStats GetSessionStats(ENUM_TRADING_SESSION session);
    double GetSessionVolatility(ENUM_TRADING_SESSION session);
    ENUM_VOLATILITY_LEVEL GetVolatilityLevel();

    // Time Analysis
    datetime GetSessionStart(ENUM_TRADING_SESSION session);
    datetime GetSessionEnd(ENUM_TRADING_SESSION session);
    int GetMinutesUntilSessionEnd();
    bool IsSessionOverlap();

    // Trading Permissions
    bool CanOpenPosition();
    bool CanClosePosition();
    bool ShouldAvoidTrading();

    // Session Reporting
    void UpdateSessionStatistics();
    SCurrentSessionInfo GetCurrentSessionInfo();
    string GetSessionReport();
};
```

#### SSessionConfig Structure

```mql5
struct SSessionConfig
{
    // Session Enable/Disable
    bool trade_asia_session;             // Trade Asia session
    bool trade_london_session;           // Trade London session
    bool trade_ny_session;               // Trade New York session

    // Session Times (Server Time)
    string asia_start;                   // Asia session start time
    string asia_end;                     // Asia session end time
    string london_start;                 // London session start time
    string london_end;                   // London session end time
    string ny_start;                     // New York session start time
    string ny_end;                       // New York session end time

    // Session Filters
    double min_session_volatility;       // Minimum volatility requirement
    double max_session_volatility;       // Maximum volatility limit
    bool require_session_breakout;       // Require session breakout
    bool avoid_session_start;            // Avoid trading at session start
    bool avoid_session_end;              // Avoid trading at session end
    int avoid_minutes;                   // Minutes to avoid at session boundaries
};
```

---

## AI Integration

### CGrokAI

**File**: `Include/AIIntegration/GrokAI.mqh`

Integrates Grok AI for fundamental analysis, sentiment analysis, and news impact assessment.

#### Key Methods

```mql5
class CGrokAI
{
public:
    // Initialization
    bool Initialize(string api_key, string base_url = "");
    void SetConfiguration(const SGrokConfig &config);
    bool TestConnection();

    // Analysis Methods
    SGrokAnalysis GetFundamentalAnalysis(string symbol);
    SGrokSentiment GetSentimentAnalysis(string symbol);
    SGrokNews GetNewsAnalysis(string symbol, int hours_back = 24);

    // Market Analysis
    double GetMarketBias(string symbol);
    ENUM_MARKET_SENTIMENT GetOverallSentiment(string symbol);
    bool ShouldAvoidTrading(string symbol);

    // News Impact
    double GetNewsImpact(const SGrokNews &news);
    bool IsHighImpactNews(const SGrokNews &news);
    datetime GetNextNewsTime(string symbol);

    // AI Signals
    SGrokSignal GetTradingSignal(string symbol);
    bool ValidateAISignal(const SGrokSignal &signal);
    double GetSignalConfidence(const SGrokSignal &signal);

    // Cache Management
    void UpdateCache();
    void ClearCache();
    bool IsCacheValid(string symbol);

    // Error Handling
    string GetLastError();
    bool IsAPIAvailable();
    void HandleAPIError(int error_code);
};
```

#### SGrokAnalysis Structure

```mql5
struct SGrokAnalysis
{
    string symbol;                       // Currency pair
    datetime timestamp;                  // Analysis timestamp
    double confidence;                   // Analysis confidence (0.0-1.0)
    ENUM_MARKET_BIAS bias;              // Market bias (bullish/bearish/neutral)
    string fundamental_factors;          // Key fundamental factors
    double economic_score;               // Economic strength score
    double technical_score;              // Technical analysis score
    double overall_score;                // Overall analysis score
    string summary;                      // Analysis summary
    string recommendations;              // Trading recommendations
};
```

---

## Backtesting Framework

### CBacktester

**File**: `Include/Utils/Backtester.mqh`

Comprehensive backtesting system with advanced statistics and optimization capabilities.

#### Key Methods

```mql5
class CBacktester
{
public:
    // Initialization
    bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
    void SetBacktestConfig(const SBacktestConfig &config);
    void SetDateRange(datetime start_date, datetime end_date);

    // Backtest Execution
    bool RunBacktest();
    bool RunOptimization();
    bool RunWalkForward();
    bool RunMonteCarloAnalysis();

    // Trade Processing
    void ProcessTick(const MqlTick &tick);
    bool OpenPosition(ENUM_ORDER_TYPE type, double volume, double price, double sl, double tp);
    bool ClosePosition(int position_id, double price);
    void UpdatePositions();

    // Statistics Calculation
    SBacktestStats CalculateStatistics();
    double CalculateSharpeRatio();
    double CalculateSortinoRatio();
    double CalculateMaxDrawdown();
    double CalculateProfitFactor();
    double CalculateRecoveryFactor();

    // Risk Metrics
    double CalculateVaR(double confidence_level = 0.95);
    double CalculateExpectedShortfall(double confidence_level = 0.95);
    double CalculateCalmarRatio();
    double CalculateUlcerIndex();

    // Report Generation
    bool GenerateReport(string filename);
    bool GenerateHTMLReport(string filename);
    bool ExportTradesToCSV(string filename);
    string GetSummaryReport();

    // Optimization
    void AddOptimizationParameter(string name, double start, double stop, double step);
    SOptimizationResult GetBestParameters();
    void SetOptimizationCriteria(ENUM_OPTIMIZATION_CRITERIA criteria);

    // Integration
    void SetEntryStrategy(CEntryStrategy* strategy);
    void SetRiskManager(CRiskManager* risk_manager);
    void SetSessionManager(CSessionManager* session_manager);
    void SetGrokAI(CGrokAI* grok_ai);
};
```

#### SBacktestStats Structure

```mql5
struct SBacktestStats
{
    // Basic Statistics
    int total_trades;                    // Total number of trades
    int winning_trades;                  // Number of winning trades
    int losing_trades;                   // Number of losing trades
    double win_rate;                     // Win rate percentage
    double gross_profit;                 // Total gross profit
    double gross_loss;                   // Total gross loss
    double net_profit;                   // Net profit
    double profit_factor;                // Profit factor

    // Trade Analysis
    double average_win;                  // Average winning trade
    double average_loss;                 // Average losing trade
    double largest_win;                  // Largest winning trade
    double largest_loss;                 // Largest losing trade
    double expected_payoff;              // Expected payoff per trade

    // Risk Metrics
    double max_drawdown;                 // Maximum drawdown
    double max_drawdown_percent;         // Maximum drawdown percentage
    double recovery_factor;              // Recovery factor
    double sharpe_ratio;                 // Sharpe ratio
    double sortino_ratio;                // Sortino ratio
    double calmar_ratio;                 // Calmar ratio

    // Time Analysis
    datetime backtest_start;             // Backtest start date
    datetime backtest_end;               // Backtest end date
    int total_bars;                      // Total bars processed
    double bars_per_trade;               // Average bars per trade

    // Advanced Metrics
    double var_95;                       // Value at Risk (95%)
    double expected_shortfall;           // Expected Shortfall
    double ulcer_index;                  // Ulcer Index
    double sterling_ratio;               // Sterling Ratio
    double burke_ratio;                  // Burke Ratio
};
```

---

## Visualization System

### CChartManager

**File**: `Include/Visualization/ChartManager.mqh`

Advanced chart visualization system for displaying market structure, signals, and performance metrics.

#### Key Methods

```mql5
class CChartManager
{
public:
    // Initialization
    bool Initialize(long chart_id = 0);
    void SetColorScheme(const SColorScheme &colors);
    void SetDisplaySettings(const SDisplaySettings &settings);

    // Market Structure Visualization
    void DrawOrderBlock(const SOrderBlock &block);
    void DrawBreakOfStructure(const SBOS &bos);
    void DrawLiquiditySweep(const SLiquiditySweep &sweep);
    void DrawFairValueGap(const SFairValueGap &fvg);
    void DrawSwingPoints(const SSwingPoint &swing);

    // Signal Visualization
    void DrawEntrySignal(const SEntrySignal &signal);
    void DrawExitSignal(double price, datetime time, ENUM_SIGNAL_TYPE type);
    void DrawSignalArrow(double price, datetime time, int arrow_code, color clr);

    // Session Visualization
    void DrawSessionBox(ENUM_TRADING_SESSION session, datetime start, datetime end);
    void UpdateSessionDisplay();
    void HighlightCurrentSession();

    // Performance Visualization
    void DrawEquityCurve();
    void DrawDrawdownChart();
    void UpdatePerformanceMetrics();
    void DisplayTradeStatistics();

    // Object Management
    void CreateChartObject(string name, ENUM_OBJECT type, datetime time, double price);
    void UpdateChartObject(string name, double price, datetime time = 0);
    void DeleteChartObject(string name);
    void DeleteAllObjects(string prefix = "");

    // Alerts and Notifications
    void ShowAlert(string message, ENUM_ALERT_TYPE type);
    void PlaySound(string sound_file);
    void SendNotification(string message);
    void SendEmail(string subject, string message);

    // Display Control
    void SetObjectVisibility(string name, bool visible);
    void SetTimeframeDisplay(ENUM_TIMEFRAMES tf);
    void RefreshChart();
    void UpdateDisplay();
};
```

#### SColorScheme Structure

```mql5
struct SColorScheme
{
    // Market Structure Colors
    color bullish_color;                 // Bullish structure color
    color bearish_color;                 // Bearish structure color
    color neutral_color;                 // Neutral structure color

    // Signal Colors
    color buy_signal_color;              // Buy signal color
    color sell_signal_color;             // Sell signal color
    color exit_signal_color;             // Exit signal color

    // Session Colors
    color asia_session_color;            // Asia session color
    color london_session_color;          // London session color
    color ny_session_color;              // New York session color
    color overlap_color;                 // Session overlap color

    // Performance Colors
    color profit_color;                  // Profit color
    color loss_color;                    // Loss color
    color breakeven_color;               // Breakeven color

    // Text and Background
    color text_color;                    // Text color
    color background_color;              // Background color
    color grid_color;                    // Grid color
};
```

---

## Utility Classes

### CUtils

**File**: `Include/Utils/Utils.mqh`

General utility functions and helpers used throughout the EA.

#### Key Methods

```mql5
class CUtils
{
public:
    // Time Functions
    static datetime ServerTimeToGMT(datetime server_time);
    static datetime GMTToServerTime(datetime gmt_time);
    static bool IsMarketOpen();
    static int GetDayOfWeek(datetime time);

    // Price Functions
    static double NormalizePrice(double price, string symbol);
    static double CalculateATR(string symbol, ENUM_TIMEFRAMES timeframe, int period);
    static double GetSpread(string symbol);
    static double GetTickValue(string symbol);

    // Math Functions
    static double CalculateStandardDeviation(double &array[]);
    static double CalculateCorrelation(double &array1[], double &array2[]);
    static double LinearRegression(double &x[], double &y[], int period);

    // String Functions
    static string TimeToString(datetime time, string format = "yyyy.mm.dd hh:mi:ss");
    static string DoubleToString(double value, int digits);
    static bool StringToDouble(string str, double &result);

    // File Functions
    static bool FileExists(string filename);
    static bool CreateDirectory(string path);
    static long GetFileSize(string filename);

    // Validation Functions
    static bool IsValidSymbol(string symbol);
    static bool IsValidTimeframe(ENUM_TIMEFRAMES timeframe);
    static bool IsValidPrice(double price);
    static bool IsValidVolume(double volume);
};
```

---

## Data Structures

### Core Structures

#### SEntrySignal

```mql5
struct SEntrySignal
{
    datetime timestamp;                  // Signal timestamp
    ENUM_ORDER_TYPE signal_type;         // Signal type (buy/sell)
    double entry_price;                  // Entry price
    double stop_loss;                    // Stop loss price
    double take_profit;                  // Take profit price
    double confidence;                   // Signal confidence (0.0-1.0)
    string reason;                       // Signal reason/description

    // Component Confirmations
    bool order_block_confirmed;          // Order block confirmation
    bool bos_confirmed;                  // Break of structure confirmation
    bool liquidity_sweep_confirmed;      // Liquidity sweep confirmation
    bool fvg_confirmed;                  // Fair value gap confirmation
    bool session_confirmed;              // Session filter confirmation
    bool ai_confirmed;                   // AI analysis confirmation

    // Risk Information
    double risk_amount;                  // Risk amount for this signal
    double position_size;                // Calculated position size
    double risk_reward_ratio;            // Risk-reward ratio

    // Metadata
    string signal_id;                    // Unique signal identifier
    bool is_valid;                       // Signal validity status
    datetime expiry_time;                // Signal expiry time
};
```

#### STradeInfo

```mql5
struct STradeInfo
{
    int trade_id;                        // Trade identifier
    string symbol;                       // Trading symbol
    ENUM_ORDER_TYPE type;                // Order type
    double volume;                       // Trade volume
    double open_price;                   // Open price
    double close_price;                  // Close price
    double stop_loss;                    // Stop loss price
    double take_profit;                  // Take profit price
    datetime open_time;                  // Open time
    datetime close_time;                 // Close time
    double profit;                       // Trade profit
    double commission;                   // Commission paid
    double swap;                         // Swap charges
    string comment;                      // Trade comment
    ENUM_TRADE_RESULT result;            // Trade result (win/loss/breakeven)
    double mae;                          // Maximum Adverse Excursion
    double mfe;                          // Maximum Favorable Excursion
    int bars_held;                       // Bars held in trade
    double entry_signal_strength;        // Entry signal strength
    string exit_reason;                  // Exit reason
};
```

---

## Enumerations

### Trading Enums

```mql5
// Order Block Types
enum ENUM_ORDER_BLOCK_TYPE
{
    ORDER_BLOCK_BULLISH,                 // Bullish order block
    ORDER_BLOCK_BEARISH,                 // Bearish order block
    ORDER_BLOCK_ALL                      // All order blocks
};

// Break of Structure Types
enum ENUM_BOS_TYPE
{
    BOS_TYPE_BULLISH,                    // Bullish BOS
    BOS_TYPE_BEARISH,                    // Bearish BOS
    BOS_TYPE_ALL                         // All BOS types
};

// BOS Confirmation Methods
enum ENUM_BOS_CONFIRMATION_METHOD
{
    BOS_CONFIRM_CLOSE,                   // Close price confirmation
    BOS_CONFIRM_BODY,                    // Candle body confirmation
    BOS_CONFIRM_WICK                     // Wick confirmation
};

// Fair Value Gap Types
enum ENUM_FVG_TYPE
{
    FVG_TYPE_BULLISH,                    // Bullish FVG
    FVG_TYPE_BEARISH,                    // Bearish FVG
    FVG_TYPE_ALL                         // All FVG types
};

// Trading Sessions
enum ENUM_TRADING_SESSION
{
    SESSION_ASIA,                        // Asia session
    SESSION_LONDON,                      // London session
    SESSION_NEW_YORK,                    // New York session
    SESSION_OVERLAP_LONDON_NY,           // London-NY overlap
    SESSION_NONE                         // No active session
};

// Session Phases
enum ENUM_SESSION_PHASE
{
    PHASE_PRE_MARKET,                    // Pre-market phase
    PHASE_OPENING,                       // Opening phase
    PHASE_ACTIVE,                        // Active trading phase
    PHASE_CLOSING,                       // Closing phase
    PHASE_POST_MARKET                    // Post-market phase
};

// Risk Models
enum ENUM_RISK_MODEL
{
    RISK_FIXED_LOT,                      // Fixed lot size
    RISK_PERCENT_BALANCE,                // Percentage of balance
    RISK_ATR_BASED,                      // ATR-based sizing
    RISK_VOLATILITY_ADJUSTED             // Volatility-adjusted sizing
};

// Stop Loss Methods
enum ENUM_SL_METHOD
{
    SL_FIXED_POINTS,                     // Fixed points
    SL_ATR_MULTIPLE,                     // ATR multiple
    SL_STRUCTURE_BASED,                  // Structure-based
    SL_VOLATILITY_BASED                  // Volatility-based
};

// Take Profit Methods
enum ENUM_TP_METHOD
{
    TP_FIXED_POINTS,                     // Fixed points
    TP_ATR_MULTIPLE,                     // ATR multiple
    TP_RISK_REWARD,                      // Risk-reward ratio
    TP_STRUCTURE_BASED                   // Structure-based
};

// Market Sentiment
enum ENUM_MARKET_SENTIMENT
{
    SENTIMENT_VERY_BEARISH,              // Very bearish
    SENTIMENT_BEARISH,                   // Bearish
    SENTIMENT_NEUTRAL,                   // Neutral
    SENTIMENT_BULLISH,                   // Bullish
    SENTIMENT_VERY_BULLISH               // Very bullish
};

// Log Levels
enum ENUM_LOG_LEVEL
{
    LOG_LEVEL_ERROR,                     // Error messages only
    LOG_LEVEL_WARNING,                   // Warning and error messages
    LOG_LEVEL_INFO,                      // Info, warning, and error messages
    LOG_LEVEL_DEBUG,                     // Debug and above
    LOG_LEVEL_TRACE                      // All messages
};
```

---

## Usage Examples

### Basic EA Setup

```mql5
// Initialize core components
CLogger logger;
CEntryStrategy entry_strategy;
CRiskManager risk_manager;
CSessionManager session_manager;
CChartManager chart_manager;

// Initialize logger
logger.Initialize("SniperEA.log", LOG_LEVEL_INFO);

// Initialize entry strategy
entry_strategy.Initialize(Symbol(), Period());
entry_strategy.ConfigureDetectors();

// Initialize risk manager
SRiskProfile risk_profile;
risk_profile.risk_model = RISK_PERCENT_BALANCE;
risk_profile.risk_percent = 2.0;
risk_profile.sl_method = SL_ATR_MULTIPLE;
risk_profile.tp_method = TP_RISK_REWARD;
risk_manager.Initialize(Symbol());
risk_manager.SetRiskProfile(risk_profile);

// Initialize session manager
SSessionConfig session_config;
session_config.trade_london_session = true;
session_config.trade_ny_session = true;
session_config.london_start = "08:00";
session_config.london_end = "17:00";
session_manager.Initialize();
session_manager.SetSessionConfig(session_config);

// Initialize chart manager
chart_manager.Initialize();
```

### Signal Processing

```mql5
// Analyze entry opportunity
SEntrySignal signal = entry_strategy.AnalyzeEntry();

if(signal.is_valid && signal.confidence > 0.7)
{
    // Check session permissions
    if(session_manager.CanOpenPosition())
    {
        // Calculate position size
        double position_size = risk_manager.CalculatePositionSize(
            signal.entry_price,
            signal.stop_loss,
            risk_manager.CalculateRiskAmount(2.0)
        );

        // Validate risk
        if(risk_manager.ValidateRisk(signal.entry_price, signal.stop_loss, position_size))
        {
            // Place order
            int ticket = OrderSend(
                Symbol(),
                signal.signal_type,
                position_size,
                signal.entry_price,
                3,
                signal.stop_loss,
                signal.take_profit,
                "SniperEA Signal",
                0,
                0,
                clrNONE
            );

            if(ticket > 0)
            {
                logger.LogInfo("Order placed successfully: " + IntegerToString(ticket));
                chart_manager.DrawEntrySignal(signal);
            }
            else
            {
                logger.LogError("Failed to place order: " + IntegerToString(GetLastError()));
            }
        }
    }
}
```

### Backtesting Example

```mql5
// Initialize backtester
CBacktester backtester;
backtester.Initialize(Symbol(), Period());

// Set backtest configuration
SBacktestConfig config;
config.start_date = StringToTime("2023.01.01");
config.end_date = StringToTime("2023.12.31");
config.initial_balance = 10000.0;
config.spread = 2.0;
config.commission = 7.0;

backtester.SetBacktestConfig(config);

// Set components
backtester.SetEntryStrategy(&entry_strategy);
backtester.SetRiskManager(&risk_manager);
backtester.SetSessionManager(&session_manager);

// Run backtest
if(backtester.RunBacktest())
{
    // Get statistics
    SBacktestStats stats = backtester.CalculateStatistics();

    // Generate report
    backtester.GenerateHTMLReport("backtest_report.html");

    // Log results
    logger.LogInfo("Backtest completed:");
    logger.LogInfo("Total trades: " + IntegerToString(stats.total_trades));
    logger.LogInfo("Win rate: " + DoubleToString(stats.win_rate, 2) + "%");
    logger.LogInfo("Net profit: " + DoubleToString(stats.net_profit, 2));
    logger.LogInfo("Max drawdown: " + DoubleToString(stats.max_drawdown_percent, 2) + "%");
    logger.LogInfo("Sharpe ratio: " + DoubleToString(stats.sharpe_ratio, 3));
}
```

---

## Error Handling

### Common Error Codes

- **ERR_INVALID_PARAMETERS**: Invalid input parameters
- **ERR_NOT_INITIALIZED**: Component not properly initialized
- **ERR_INSUFFICIENT_DATA**: Insufficient historical data
- **ERR_INVALID_SYMBOL**: Invalid trading symbol
- **ERR_MARKET_CLOSED**: Market is closed
- **ERR_INSUFFICIENT_FUNDS**: Insufficient account funds
- **ERR_INVALID_STOPS**: Invalid stop loss or take profit levels
- **ERR_API_CONNECTION**: API connection failed
- **ERR_FILE_ACCESS**: File access error

### Error Handling Best Practices

1. Always check return values of initialization methods
2. Validate input parameters before processing
3. Use try-catch blocks for critical operations
4. Log errors with sufficient context information
5. Implement graceful degradation for non-critical failures
6. Provide meaningful error messages to users

---

## Performance Considerations

### Optimization Tips

1. **Minimize Indicator Calculations**: Cache indicator values and update only when necessary
2. **Efficient Object Management**: Clean up unused chart objects regularly
3. **Smart Data Processing**: Process only new bars, avoid recalculating historical data
4. **Memory Management**: Release unused arrays and objects
5. **API Rate Limiting**: Implement proper rate limiting for external API calls

### Resource Usage

- **Memory**: Typical usage 50-100MB depending on configuration
- **CPU**: Low to moderate CPU usage, spikes during analysis
- **Network**: Minimal for basic operation, higher with AI integration
- **Storage**: Log files and backtest data can grow over time

---

This API documentation provides comprehensive coverage of all classes, methods, and structures in the MT5 Sniper EA system. For additional examples and advanced usage patterns, refer to the example files in the `/examples` directory.