PropFirmGuard/PropFirmGuard.mq5

//+------------------------------------------------------------------+
//|                                                PropFirmGuard.mq5 |
//|                                  Copyright 2026, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Standard Library                                                 |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| Enumerations                                                     |
//+------------------------------------------------------------------+
//| Represents the general compliance condition of the account.      |
//+------------------------------------------------------------------+
enum ENUM_COMPLIANCE_STATUS
  {
   COMPLIANCE_SAFE = 0,          // Account is operating within configured limits
   COMPLIANCE_WARNING,           // Account is approaching a compliance limit
   COMPLIANCE_CRITICAL,          // Account is very close to a compliance limit
   COMPLIANCE_BREACHED           // A configured compliance limit has been breached
  };

//+------------------------------------------------------------------+
//| Profit target status                                             |
//+------------------------------------------------------------------+
//| Represents progress toward the configured account profit target. |
//+------------------------------------------------------------------+
enum ENUM_TARGET_STATUS
  {
   TARGET_IN_PROGRESS = 0,       // Target is still being pursued
   TARGET_NEARING,               // At least 90% of the target has been reached
   TARGET_REACHED                // Required target balance has been achieved
  };

//+------------------------------------------------------------------+
//| Overall guard status                                             |
//+------------------------------------------------------------------+
enum ENUM_GUARD_STATUS
  {
   GUARD_SAFE = 0,               // All monitored rules are within safe limits
   GUARD_TARGET_REACHED,         // Profit target has been achieved
   GUARD_WARNING,                // At least one rule is in warning state
   GUARD_CRITICAL,               // At least one rule is in critical state
   GUARD_BREACHED                // At least one drawdown rule has been breached
  };

//+------------------------------------------------------------------+
//| News monitoring status                                           |
//+------------------------------------------------------------------+
enum ENUM_NEWS_STATUS
  {
   NEWS_DISABLED = 0,             // Economic news monitoring is disabled
   NEWS_NO_EXPOSURE,              // No supported open positions require news monitoring
   NEWS_NO_EVENT,                 // No relevant event was found
   NEWS_SAFE,                     // Relevant event exists but restriction is inactive
   NEWS_RESTRICTED,               // Current time is inside the restricted news window
   NEWS_UNAVAILABLE               // Calendar data could not be retrieved
  };

//+------------------------------------------------------------------+
//| News position match status                                       |
//+------------------------------------------------------------------+
//| Describes whether an open position is affected by the selected   |
//| Economic Calendar event.                                         |
//+------------------------------------------------------------------+
enum ENUM_NEWS_POSITION_STATUS
  {
   NEWS_POSITION_NOT_AFFECTED = 0, // Position does not use the event currency
   NEWS_POSITION_AFFECTED,         // Position is exposed to the event currency
   NEWS_POSITION_UNSUPPORTED       // Position is outside current Forex/XAUUSD scope
  };

//+------------------------------------------------------------------+
//| News holding status                                              |
//+------------------------------------------------------------------+
//| Describes the account's current holding-rule condition around    |
//| the selected Economic Calendar event.                            |
//+------------------------------------------------------------------+
enum ENUM_NEWS_HOLDING_STATUS
  {
   NEWS_HOLDING_CLEAR = 0,        // No active holding restriction
   NEWS_HOLDING_ALLOWED,          // Restricted window active but holding is permitted
   NEWS_HOLDING_WARNING,          // Event is approaching and affected positions exist
   NEWS_HOLDING_PROTECTION        // Restricted window active and protection is required
  };
  
//+------------------------------------------------------------------+
//| Protection action                                                |
//+------------------------------------------------------------------+
//| Defines what Prop Firm Guard should do when a monitored rule     |
//| requires protective action.                                      |
//+------------------------------------------------------------------+
enum ENUM_PROTECTION_ACTION
  {
   PROTECTION_WARN_ONLY = 0,       // Report the condition without closing positions
   PROTECTION_CLOSE_AFFECTED,      // Close positions affected by the triggering rule
   PROTECTION_CLOSE_ALL            // Close every open account position
  };

//+------------------------------------------------------------------+
//| Inputs                                                           |
//+------------------------------------------------------------------+
input group "General"
input int    InpTimerSeconds            = 1;      // Dashboard update interval in seconds
input int    InpDashboardX              = 10;     // Dashboard horizontal position
input int    InpDashboardY              = 105;    // Dashboard vertical position
input bool   InpEnableAlerts            = true;   // Enable terminal alerts
input bool   InpEnablePushNotifications = false;  // Enable mobile push notifications

input group "Prop Firm Rules"
input double InpInitialAccountBalance  = 20000.0; // Initial prop-firm account balance
input double InpDailyDrawdownPercent   = 5.0;     // Maximum permitted daily drawdown
input double InpOverallDrawdownPercent = 10.0;    // Maximum permitted overall drawdown
input double InpProfitTargetPercent    = 8.0;     // Required profit target

input group "Warning Levels"
input double InpWarningLevelPercent  = 70.0;      // Loss limit usage that triggers warning
input double InpCriticalLevelPercent = 90.0;      // Loss limit usage that triggers critical state

input group "News Filter"
input bool   InpEnableNewsFilter       = true;    // Enable economic news monitoring
input ENUM_CALENDAR_EVENT_IMPORTANCE InpNewsImportance = CALENDAR_IMPORTANCE_HIGH; // Minimum monitored importance
input int    InpMinutesBeforeNews      = 10;      // Restricted minutes before news
input int    InpMinutesAfterNews       = 10;      // Restricted minutes after news
input bool   InpAllowNewsHolding       = true;    // Allow positions to remain open during news

input group "Protection Actions"
input ENUM_PROTECTION_ACTION InpDailyDrawdownAction   = PROTECTION_WARN_ONLY; // Daily breach action
input ENUM_PROTECTION_ACTION InpOverallDrawdownAction = PROTECTION_WARN_ONLY; // Overall breach action
input ENUM_PROTECTION_ACTION InpNewsRestrictionAction = PROTECTION_WARN_ONLY; // News restriction action

//+------------------------------------------------------------------+
//| Account state structure                                          |
//+------------------------------------------------------------------+
//| Holds the live account values required by the monitoring logic.  |
//+------------------------------------------------------------------+
struct SAccountState
  {
   long                    login;       // Trading account login number
   double                  balance;     // Current account balance
   double                  equity;      // Current account equity
   double                  floatingPL;  // Current floating profit or loss
   ENUM_COMPLIANCE_STATUS  status;      // Current overall compliance status
  };

//+------------------------------------------------------------------+
//| Account settings structure                                       |
//+------------------------------------------------------------------+
//| Stores the main prop-firm rules associated with this account.    |
//+------------------------------------------------------------------+
struct SAccountSettings
  {
   long              accountLogin;           // Trading account login
   string            accountServer;          // Broker trading server
   double            initialBalance;         // Initial prop-firm account balance
   double            dailyDrawdownPercent;   // Maximum daily drawdown
   double            overallDrawdownPercent; // Maximum overall drawdown
   double            profitTargetPercent;    // Required profit target
   datetime          updatedAt;              // Last settings update time
  };

//+------------------------------------------------------------------+
//| Daily session structure                                          |
//+------------------------------------------------------------------+
//| Represents the persistent state associated with one trading day. |
//+------------------------------------------------------------------+
struct SDailySession
  {
   long              accountLogin;             // Trading account login
   string            accountServer;            // Broker trading server
   string            tradingDate;              // Trading date represented by this session
   double            startingBalance;          // Confirmed daily starting balance
   double            startingEquity;           // Equity captured when the baseline is confirmed
   bool              balanceConfirmed;         // Whether the starting balance has been confirmed
   double            latestBalance;            // Most recently recorded account balance
   double            latestEquity;             // Most recently recorded account equity
   double            dailyLoss;                // Persisted daily loss value
   double            maximumDailyLossReached;  // Highest daily loss recorded during the session
   double            targetProgress;           // Persisted profit-target progress
   string            sessionStatus;            // Current persisted session status
   datetime          createdAt;                // Time the session record was created
   datetime          updatedAt;                // Time the session record was last updated
  };

//+------------------------------------------------------------------+
//| Daily drawdown structure                                         |
//+------------------------------------------------------------------+
//| Holds the calculated daily risk values for the active session.   |
//+------------------------------------------------------------------+
struct SDailyDrawdownState
  {
   double                  startingBalance;        // Confirmed daily starting balance
   double                  currentEquity;          // Current live account equity
   double                  maximumDailyLoss;       // Maximum money that may be lost today
   double                  currentDailyLoss;       // Current loss measured from starting balance
   double                  drawdownPercent;        // Current loss as percentage of starting balance
   double                  limitUsagePercent;      // Percentage of daily loss allowance already used
   double                  remainingAllowance;     // Money remaining before daily breach
   ENUM_COMPLIANCE_STATUS  status;                 // Current daily drawdown status
  };

//+------------------------------------------------------------------+
//| Overall drawdown structure                                       |
//+------------------------------------------------------------------+
//| Holds the live calculations for the static overall loss rule.    |
//+------------------------------------------------------------------+
struct SOverallDrawdownState
  {
   double                  initialBalance;         // Initial prop-firm account balance
   double                  currentEquity;          // Current live account equity
   double                  maximumOverallLoss;     // Maximum permitted overall loss
   double                  overallFloor;           // Minimum permitted account equity
   double                  currentOverallLoss;     // Current loss from initial balance
   double                  limitUsagePercent;      // Percentage of overall allowance used
   double                  remainingAllowance;     // Money remaining before breach
   ENUM_COMPLIANCE_STATUS  status;                 // Current overall drawdown status
  };

//+------------------------------------------------------------------+
//| Profit target structure                                          |
//+------------------------------------------------------------------+
//| Holds the live calculations used to track challenge progress.    |
//+------------------------------------------------------------------+
struct SProfitTargetState
  {
   double              initialBalance;        // Initial prop-firm account balance
   double              currentBalance;        // Current realized account balance
   double              targetAmount;          // Profit required in account currency
   double              targetBalance;         // Balance required to complete the target
   double              currentProfit;         // Realized profit above initial balance
   double              progressPercent;       // Percentage of target already completed
   double              remainingProfit;       // Profit still required to reach target
   ENUM_TARGET_STATUS  status;                // Current target progress state
  };

//+------------------------------------------------------------------+
//| News monitoring structure                                        |
//+------------------------------------------------------------------+
struct SNewsState
  {
   bool                            hasExposure;              // Whether supported open positions exist
   int                             monitoredCurrencies;      // Number of unique monitored currencies
   string                          currencyList;             // Monitored currency list
   bool                            eventFound;               // Whether a relevant event was located
   string                          eventCurrency;            // Currency affected by selected event
   ulong                           eventId;                  // Economic Calendar event identifier
   string                          eventName;                // Economic event name
   ENUM_CALENDAR_EVENT_IMPORTANCE  importance;               // Event importance
   datetime                        eventTime;                // Event time in trade-server time
   long                            secondsToEvent;           // Signed distance to event
   datetime                        restrictionStart;         // Beginning of restricted news window
   datetime                        restrictionEnd;           // End of restricted news window
   bool                            restrictedWindow;         // Whether restriction is currently active
   int                             affectedPositions;        // Positions affected by selected event
   int                             protectionPositions;      // Affected positions requiring protection
   ENUM_NEWS_STATUS                status;                   // Current news-monitoring status
   ENUM_NEWS_HOLDING_STATUS        holdingStatus;            // Current news-holding condition
  };

//+------------------------------------------------------------------+
//| News position match structure                                    |
//+------------------------------------------------------------------+
struct SNewsPositionMatch
  {
   ulong                       ticket;             // Position ticket
   string                      symbol;             // Position symbol
   string                      currency1;          // First relevant currency
   string                      currency2;          // Second relevant currency
   ENUM_NEWS_POSITION_STATUS   status;             // Event-currency classification
   bool                        protectionRequired; // Whether protection is required
  };
  
//+------------------------------------------------------------------+
//| Alert state                                                      |
//+------------------------------------------------------------------+
//| Remembers which conditions have already generated notifications. |
//+------------------------------------------------------------------+
struct SAlertState
  {
   ENUM_COMPLIANCE_STATUS dailyDrawdownStatus;
   ENUM_COMPLIANCE_STATUS overallDrawdownStatus;
   ENUM_TARGET_STATUS     profitTargetStatus;
   ulong                  newsEventId;
   bool                   newsApproachAlerted;
   bool                   newsRestrictedAlerted;
  };

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
SAccountState         g_accountState;                      // Latest monitored account state
SAccountSettings      g_accountSettings;                   // Persisted prop-firm settings
SDailySession         g_dailySession;                      // Current trading-day record
SDailyDrawdownState   g_dailyDrawdown;                     // Current daily drawdown calculations
SOverallDrawdownState g_overallDrawdown;                   // Current overall drawdown calculations
SProfitTargetState    g_profitTarget;                      // Current profit-target calculations
SNewsState            g_newsState;                        // Current economic news state
SNewsPositionMatch    g_newsPositionMatches[];            // Classification of open positions
SAlertState           g_alertState;                       // Alert transition memory

CTrade                g_trade;                            // Synchronous trade execution helper

string                g_startBalanceEdit = "PFG_StartBalanceEdit"; // Starting balance input field
string                g_confirmButton = "PFG_ConfirmBalance";       // Daily balance confirmation button
string                g_databaseName = "prop_firm_compliance.sqlite"; // SQLite database file

int                   g_database = INVALID_HANDLE;         // Active SQLite database handle
bool                  g_hasDailySession = false;           // Whether a daily session is loaded

bool                  g_dailyBreachWarned = false;         // Prevent repeated daily breach warnings
bool                  g_overallBreachWarned = false;       // Prevent repeated overall breach warnings
ulong                 g_lastNewsWarnedEventId = 0;         // Prevent repeated warning for same news event

//+------------------------------------------------------------------+
//| Validate compliance inputs                                       |
//+------------------------------------------------------------------+
bool ValidateComplianceInputs()
  {
//--- Validate the initial account balance
   if(InpInitialAccountBalance <= 0.0)
     {
      Print("Prop Firm Guard: Initial account balance must be greater than zero.");

      return(false);
     }

//--- Validate the daily drawdown percentage
   if(InpDailyDrawdownPercent <= 0.0 ||
      InpDailyDrawdownPercent > 100.0)
     {
      Print("Prop Firm Guard: Daily drawdown percentage must be between 0 and 100.");

      return(false);
     }

//--- Validate the overall drawdown percentage
   if(InpOverallDrawdownPercent <= 0.0 ||
      InpOverallDrawdownPercent > 100.0)
     {
      Print("Prop Firm Guard: Overall drawdown percentage must be between 0 and 100.");

      return(false);
     }

//--- Validate the profit target percentage
   if(InpProfitTargetPercent <= 0.0 ||
      InpProfitTargetPercent > 100.0)
     {
      Print("Prop Firm Guard: Profit target percentage must be between 0 and 100.");

      return(false);
     }

//--- Validate the warning threshold
   if(InpWarningLevelPercent <= 0.0 ||
      InpWarningLevelPercent >= InpCriticalLevelPercent)
     {
      Print("Prop Firm Guard: Warning level must be greater than 0 and below the critical level.");

      return(false);
     }

//--- Validate the critical threshold
   if(InpCriticalLevelPercent <= InpWarningLevelPercent ||
      InpCriticalLevelPercent >= 100.0)
     {
      Print("Prop Firm Guard: Critical level must be above the warning level and below 100.");

      return(false);
     }

//--- Validate the news restriction windows
   if(InpMinutesBeforeNews < 0 ||
      InpMinutesAfterNews < 0)
     {
      Print("Prop Firm Guard: News restriction minutes cannot be negative.");

      return(false);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Update account state                                             |
//+------------------------------------------------------------------+
void UpdateAccountState()
  {
//--- Read the current account values
   g_accountState.login = AccountInfoInteger(ACCOUNT_LOGIN);
   g_accountState.balance = AccountInfoDouble(ACCOUNT_BALANCE);
   g_accountState.equity = AccountInfoDouble(ACCOUNT_EQUITY);

//--- Derive the current floating profit or loss
   g_accountState.floatingPL = g_accountState.equity - g_accountState.balance;

//--- Initialize compliance status before rule calculations are added
   g_accountState.status = COMPLIANCE_SAFE;
  }

//+------------------------------------------------------------------+
//| Calculate daily drawdown                                         |
//+------------------------------------------------------------------+
void CalculateDailyDrawdown()
  {
//--- Reset the state until the daily starting balance is confirmed
   if(!g_dailySession.balanceConfirmed ||
      g_dailySession.startingBalance <= 0.0)
     {
      g_dailyDrawdown.startingBalance    = 0.0;
      g_dailyDrawdown.currentEquity      = g_accountState.equity;
      g_dailyDrawdown.maximumDailyLoss   = 0.0;
      g_dailyDrawdown.currentDailyLoss   = 0.0;
      g_dailyDrawdown.drawdownPercent    = 0.0;
      g_dailyDrawdown.limitUsagePercent  = 0.0;
      g_dailyDrawdown.remainingAllowance = 0.0;
      g_dailyDrawdown.status             = COMPLIANCE_SAFE;

      return;
     }

//--- Read the active daily reference and current equity
   g_dailyDrawdown.startingBalance = g_dailySession.startingBalance;
   g_dailyDrawdown.currentEquity   = g_accountState.equity;

//--- Calculate the permitted daily loss
   g_dailyDrawdown.maximumDailyLoss =
      g_dailyDrawdown.startingBalance *
      g_accountSettings.dailyDrawdownPercent / 100.0;

//--- Calculate the current daily loss
   g_dailyDrawdown.currentDailyLoss =
      g_dailyDrawdown.startingBalance -
      g_dailyDrawdown.currentEquity;

   if(g_dailyDrawdown.currentDailyLoss < 0.0)
      g_dailyDrawdown.currentDailyLoss = 0.0;

//--- Calculate the loss percentage
   g_dailyDrawdown.drawdownPercent =
      g_dailyDrawdown.currentDailyLoss /
      g_dailyDrawdown.startingBalance * 100.0;

//--- Calculate daily limit usage
   if(g_dailyDrawdown.maximumDailyLoss > 0.0)
     {
      g_dailyDrawdown.limitUsagePercent =
         g_dailyDrawdown.currentDailyLoss /
         g_dailyDrawdown.maximumDailyLoss * 100.0;
     }
   else
     {
      g_dailyDrawdown.limitUsagePercent = 0.0;
     }

//--- Calculate the remaining allowance
   g_dailyDrawdown.remainingAllowance =
      g_dailyDrawdown.maximumDailyLoss -
      g_dailyDrawdown.currentDailyLoss;

   if(g_dailyDrawdown.remainingAllowance < 0.0)
      g_dailyDrawdown.remainingAllowance = 0.0;

//--- Classify the current daily drawdown state
   if(g_dailyDrawdown.limitUsagePercent >= 100.0)
      g_dailyDrawdown.status = COMPLIANCE_BREACHED;
   else
      if(g_dailyDrawdown.limitUsagePercent >= InpCriticalLevelPercent)
         g_dailyDrawdown.status = COMPLIANCE_CRITICAL;
      else
         if(g_dailyDrawdown.limitUsagePercent >= InpWarningLevelPercent)
            g_dailyDrawdown.status = COMPLIANCE_WARNING;
         else
            g_dailyDrawdown.status = COMPLIANCE_SAFE;
  }

//+------------------------------------------------------------------+
//| Calculate overall drawdown                                       |
//+------------------------------------------------------------------+
void CalculateOverallDrawdown()
  {
//--- Read the fixed challenge reference and current equity
   g_overallDrawdown.initialBalance = g_accountSettings.initialBalance;
   g_overallDrawdown.currentEquity  = g_accountState.equity;

//--- Calculate the maximum permitted overall loss
   g_overallDrawdown.maximumOverallLoss =
      g_overallDrawdown.initialBalance *
      g_accountSettings.overallDrawdownPercent / 100.0;

//--- Calculate the static overall equity floor
   g_overallDrawdown.overallFloor =
      g_overallDrawdown.initialBalance -
      g_overallDrawdown.maximumOverallLoss;

//--- Calculate the current loss from the initial balance
   g_overallDrawdown.currentOverallLoss =
      g_overallDrawdown.initialBalance -
      g_overallDrawdown.currentEquity;

   if(g_overallDrawdown.currentOverallLoss < 0.0)
      g_overallDrawdown.currentOverallLoss = 0.0;

//--- Calculate overall limit usage
   if(g_overallDrawdown.maximumOverallLoss > 0.0)
     {
      g_overallDrawdown.limitUsagePercent =
         g_overallDrawdown.currentOverallLoss /
         g_overallDrawdown.maximumOverallLoss * 100.0;
     }
   else
     {
      g_overallDrawdown.limitUsagePercent = 0.0;
     }

//--- Calculate the remaining overall allowance
   g_overallDrawdown.remainingAllowance =
      g_overallDrawdown.maximumOverallLoss -
      g_overallDrawdown.currentOverallLoss;

   if(g_overallDrawdown.remainingAllowance < 0.0)
      g_overallDrawdown.remainingAllowance = 0.0;

//--- Classify the current overall drawdown state
   if(g_overallDrawdown.limitUsagePercent >= 100.0)
      g_overallDrawdown.status = COMPLIANCE_BREACHED;
   else
      if(g_overallDrawdown.limitUsagePercent >= InpCriticalLevelPercent)
         g_overallDrawdown.status = COMPLIANCE_CRITICAL;
      else
         if(g_overallDrawdown.limitUsagePercent >= InpWarningLevelPercent)
            g_overallDrawdown.status = COMPLIANCE_WARNING;
         else
            g_overallDrawdown.status = COMPLIANCE_SAFE;
  }

//+------------------------------------------------------------------+
//| Calculate profit target                                          |
//+------------------------------------------------------------------+
void CalculateProfitTarget()
  {
//--- Read the fixed challenge reference and realized balance
   g_profitTarget.initialBalance = g_accountSettings.initialBalance;
   g_profitTarget.currentBalance = g_accountState.balance;

//--- Calculate the required profit and target balance
   g_profitTarget.targetAmount =
      g_profitTarget.initialBalance *
      g_accountSettings.profitTargetPercent / 100.0;

   g_profitTarget.targetBalance =
      g_profitTarget.initialBalance +
      g_profitTarget.targetAmount;

//--- Calculate realized profit above the initial balance
   g_profitTarget.currentProfit =
      g_profitTarget.currentBalance -
      g_profitTarget.initialBalance;

   if(g_profitTarget.currentProfit < 0.0)
      g_profitTarget.currentProfit = 0.0;

//--- Calculate target progress
   if(g_profitTarget.targetAmount > 0.0)
     {
      g_profitTarget.progressPercent =
         g_profitTarget.currentProfit /
         g_profitTarget.targetAmount * 100.0;
     }
   else
     {
      g_profitTarget.progressPercent = 0.0;
     }

   if(g_profitTarget.progressPercent > 100.0)
      g_profitTarget.progressPercent = 100.0;

//--- Calculate the remaining required profit
   g_profitTarget.remainingProfit =
      g_profitTarget.targetAmount -
      g_profitTarget.currentProfit;

   if(g_profitTarget.remainingProfit < 0.0)
      g_profitTarget.remainingProfit = 0.0;

//--- Classify the current target state
   if(g_profitTarget.currentBalance >= g_profitTarget.targetBalance)
      g_profitTarget.status = TARGET_REACHED;
   else
      if(g_profitTarget.progressPercent >= 90.0)
         g_profitTarget.status = TARGET_NEARING;
      else
         g_profitTarget.status = TARGET_IN_PROGRESS;
  }

//+------------------------------------------------------------------+
//| Initialize news state                                            |
//+------------------------------------------------------------------+
void InitializeNewsState()
  {
//--- Clear account-exposure information
   g_newsState.hasExposure = false;
   g_newsState.monitoredCurrencies = 0;
   g_newsState.currencyList = "";

//--- Clear the previously selected calendar event
   g_newsState.eventFound = false;
   g_newsState.eventCurrency = "";
   g_newsState.eventId = 0;
   g_newsState.eventName = "";
   g_newsState.importance = CALENDAR_IMPORTANCE_NONE;
   g_newsState.eventTime = 0;

//--- Reset event timing and restriction-window state
   g_newsState.secondsToEvent = 0;
   g_newsState.restrictionStart = 0;
   g_newsState.restrictionEnd = 0;
   g_newsState.restrictedWindow = false;

//--- Set the initial monitoring condition
   g_newsState.status =
      InpEnableNewsFilter ? NEWS_NO_EXPOSURE : NEWS_DISABLED;
  }
  
//+------------------------------------------------------------------+
//| Initialize alert state                                           |
//+------------------------------------------------------------------+
void InitializeAlertState()
  {
//--- Synchronize financial alert memory with the current rule states
   g_alertState.dailyDrawdownStatus = g_dailyDrawdown.status;
   g_alertState.overallDrawdownStatus = g_overallDrawdown.status;
   g_alertState.profitTargetStatus = g_profitTarget.status;

//--- Clear Economic Calendar notification tracking
   g_alertState.newsEventId = 0;
   g_alertState.newsApproachAlerted = false;
   g_alertState.newsRestrictedAlerted = false;
  }
  
//+------------------------------------------------------------------+
//| Send guard notification                                          |
//+------------------------------------------------------------------+
void SendGuardNotification(const string message)
  {
//--- Record every generated notification in the terminal log
   Print("Prop Firm Guard: ",
         message);

//--- Show a terminal alert when enabled
   if(InpEnableAlerts)
      Alert("Prop Firm Guard: ",
            message);

//--- Stop here when mobile push notifications are disabled
   if(!InpEnablePushNotifications)
      return;

//--- Confirm that push notifications are enabled in MetaTrader
   if(!TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED))
     {
      Print("Prop Firm Guard: Push notifications are enabled in the EA ",
            "but disabled in the terminal settings.");

      return;
     }

//--- Send the optional mobile notification
   ResetLastError();

   if(!SendNotification("Prop Firm Guard: " + message))
     {
      Print("Prop Firm Guard: Could not send push notification. Error: ",
            GetLastError());
     }
  }
  
//+------------------------------------------------------------------+
//| Convert calendar importance to text                              |
//+------------------------------------------------------------------+
string CalendarImportanceToString(
   const ENUM_CALENDAR_EVENT_IMPORTANCE importance)
  {
   switch(importance)
     {
      case CALENDAR_IMPORTANCE_HIGH:
         return("HIGH");

      case CALENDAR_IMPORTANCE_MODERATE:
         return("MODERATE");

      case CALENDAR_IMPORTANCE_LOW:
         return("LOW");

      case CALENDAR_IMPORTANCE_NONE:
      default:
         return("NONE");
     }
  }
  
//+------------------------------------------------------------------+
//| Build daily drawdown alert                                       |
//+------------------------------------------------------------------+
string BuildDailyDrawdownAlert(const ENUM_COMPLIANCE_STATUS status)
  {
   switch(status)
     {
      case COMPLIANCE_WARNING:
         return("Daily drawdown reached WARNING level.");

      case COMPLIANCE_CRITICAL:
         return("CRITICAL: Only " +
                DoubleToString(g_dailyDrawdown.remainingAllowance, 2) +
                " remains before the daily loss limit.");

      case COMPLIANCE_BREACHED:
         return("Daily drawdown limit breached.");

      case COMPLIANCE_SAFE:
      default:
         return("");
     }
  }

//+------------------------------------------------------------------+
//| Build overall drawdown alert                                     |
//+------------------------------------------------------------------+
string BuildOverallDrawdownAlert(const ENUM_COMPLIANCE_STATUS status)
  {
   switch(status)
     {
      case COMPLIANCE_WARNING:
         return("Overall drawdown reached WARNING level.");

      case COMPLIANCE_CRITICAL:
         return("CRITICAL: Only " +
                DoubleToString(g_overallDrawdown.remainingAllowance, 2) +
                " remains before the overall loss limit.");

      case COMPLIANCE_BREACHED:
         return("Overall drawdown limit breached.");

      case COMPLIANCE_SAFE:
      default:
         return("");
     }
  }
  
//+------------------------------------------------------------------+
//| Check daily drawdown alert                                       |
//+------------------------------------------------------------------+
void CheckDailyDrawdownAlert()
  {
//--- Daily alerts require a confirmed session baseline
   if(!g_dailySession.balanceConfirmed)
      return;

//--- An unchanged state has already been observed
   if(g_dailyDrawdown.status == g_alertState.dailyDrawdownStatus)
      return;

//--- Remember the new state before deciding whether it needs a message
   g_alertState.dailyDrawdownStatus = g_dailyDrawdown.status;

   string message = BuildDailyDrawdownAlert(g_dailyDrawdown.status);

   if(message == "")
      return;

//--- Report the newly entered drawdown state
   SendGuardNotification(message);
  }

//+------------------------------------------------------------------+
//| Check overall drawdown alert                                     |
//+------------------------------------------------------------------+
void CheckOverallDrawdownAlert()
  {
//--- Ignore an unchanged overall drawdown state
   if(g_overallDrawdown.status == g_alertState.overallDrawdownStatus)
      return;

//--- Store the transition before generating its message
   g_alertState.overallDrawdownStatus = g_overallDrawdown.status;

   string message = BuildOverallDrawdownAlert(g_overallDrawdown.status);

   if(message == "")
      return;

//--- Report the newly entered drawdown state
   SendGuardNotification(message);
  }

//+------------------------------------------------------------------+
//| Check profit target alert                                        |
//+------------------------------------------------------------------+
void CheckProfitTargetAlert()
  {
//--- Ignore an unchanged target state
   if(g_profitTarget.status == g_alertState.profitTargetStatus)
      return;

//--- Remember the new target state
   g_alertState.profitTargetStatus = g_profitTarget.status;

//--- Only completion produces a target notification
   if(g_profitTarget.status != TARGET_REACHED)
      return;

   SendGuardNotification("Profit target reached.");
  }
  
//+------------------------------------------------------------------+
//| Check economic news alerts                                       |
//+------------------------------------------------------------------+
void CheckNewsAlert()
  {
//--- News alerts require a relevant event and affected exposure
   if(!InpEnableNewsFilter ||
      !g_newsState.eventFound ||
      g_newsState.affectedPositions == 0)
      return;

//--- Give every newly selected event a fresh notification state
   if(g_alertState.newsEventId != g_newsState.eventId)
     {
      g_alertState.newsEventId = g_newsState.eventId;
      g_alertState.newsApproachAlerted = false;
      g_alertState.newsRestrictedAlerted = false;
     }

   long warningThreshold =
      (long)InpMinutesBeforeNews * 60;

//--- Issue one advance warning inside the configured pre-news interval
   if(g_newsState.secondsToEvent > 0 &&
      g_newsState.secondsToEvent <= warningThreshold &&
      !g_alertState.newsApproachAlerted)
     {
      string message =
         CalendarImportanceToString(g_newsState.importance) +
         "-impact " +
         g_newsState.eventCurrency +
         " news in " +
         IntegerToString((int)MathCeil((double)g_newsState.secondsToEvent / 60.0)) +
         " minute(s): " +
         g_newsState.eventName +
         ".";

      g_alertState.newsApproachAlerted = true;

      SendGuardNotification(message);
     }

//--- Report prohibited holding once the active restriction requires protection
   if(g_newsState.holdingStatus == NEWS_HOLDING_PROTECTION &&
      !g_alertState.newsRestrictedAlerted)
     {
      string message =
         "News holding restriction active for " +
         g_newsState.eventCurrency +
         " " +
         g_newsState.eventName +
         ".";

      g_alertState.newsRestrictedAlerted = true;

      SendGuardNotification(message);
     }
  }
  
//+------------------------------------------------------------------+
//| Manage alerts                                                    |
//+------------------------------------------------------------------+
void ManageAlerts()
  {
//--- Check financial-rule transitions
   CheckDailyDrawdownAlert();
   CheckOverallDrawdownAlert();
   CheckProfitTargetAlert();

//--- Check event-specific economic-news transitions
   CheckNewsAlert();
  }

//+------------------------------------------------------------------+
//| Check whether currency already exists in array                    |
//+------------------------------------------------------------------+
bool CurrencyExists(const string &currencies[],
                    const string currency)
  {
   int count = ArraySize(currencies);

//--- Search the current currency set
   for(int i = 0; i < count; i++)
     {
      if(currencies[i] == currency)
         return(true);
     }

   return(false);
  }

//+------------------------------------------------------------------+
//| Add unique currency to array                                     |
//+------------------------------------------------------------------+
bool AddUniqueCurrency(string &currencies[],
                       const string currency)
  {
//--- Ignore an empty currency value
   if(currency == "")
      return(true);

//--- Keep each monitored currency only once
   if(CurrencyExists(currencies, currency))
      return(true);

   int currentSize = ArraySize(currencies);

//--- Extend the currency array
   if(ArrayResize(currencies, currentSize + 1) != currentSize + 1)
     {
      Print("Prop Firm Guard: Could not expand monitored currency array.");

      return(false);
     }

   currencies[currentSize] = currency;

   return(true);
  }

//+------------------------------------------------------------------+
//| Get symbol currencies relevant to news                           |
//+------------------------------------------------------------------+
bool GetSymbolNewsCurrencies(const string symbol,
                             string &currency1,
                             string &currency2)
  {
   string baseCurrency;
   string profitCurrency;
   long calculationMode = 0;

   currency1 = "";
   currency2 = "";

//--- Read the currencies defined by the broker for this symbol
   ResetLastError();

   if(!SymbolInfoString(symbol,
                        SYMBOL_CURRENCY_BASE,
                        baseCurrency))
     {
      Print("Prop Firm Guard: Could not read base currency for ",
            symbol,
            ". Error: ",
            GetLastError());

      return(false);
     }

   ResetLastError();

   if(!SymbolInfoString(symbol,
                        SYMBOL_CURRENCY_PROFIT,
                        profitCurrency))
     {
      Print("Prop Firm Guard: Could not read profit currency for ",
            symbol,
            ". Error: ",
            GetLastError());

      return(false);
     }

//--- Treat XAUUSD as USD calendar exposure
   if(baseCurrency == "XAU" &&
      profitCurrency == "USD")
     {
      currency1 = "USD";

      return(true);
     }

//--- Read the symbol's trading calculation model
   ResetLastError();

   if(!SymbolInfoInteger(symbol,
                         SYMBOL_TRADE_CALC_MODE,
                         calculationMode))
     {
      Print("Prop Firm Guard: Could not read calculation mode for ",
            symbol,
            ". Error: ",
            GetLastError());

      return(false);
     }

//--- Ignore instruments outside the supported Forex calculation modes
   if(calculationMode != SYMBOL_CALC_MODE_FOREX &&
      calculationMode != SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE)
      return(true);

   currency1 = baseCurrency;
   currency2 = profitCurrency;

   return(true);
  }

//+------------------------------------------------------------------+
//| Match open positions to selected news event                      |
//+------------------------------------------------------------------+
void MatchOpenPositionsToNews()
  {
//--- Remove classifications from the previous monitoring cycle
   ArrayResize(g_newsPositionMatches, 0);

//--- Position matching requires an actual selected calendar event
   if(!g_newsState.eventFound ||
      g_newsState.eventCurrency == "")
      return;

   int totalPositions = PositionsTotal();

//--- Classify every currently open account position
   for(int i = 0; i < totalPositions; i++)
     {
      ResetLastError();

      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
        {
         Print("Prop Firm Guard: Could not retrieve position ticket at index ",
               i,
               ". Error: ",
               GetLastError());

         continue;
        }

      string symbol;

      if(!PositionGetString(POSITION_SYMBOL,
                            symbol))
        {
         Print("Prop Firm Guard: Could not retrieve symbol for position ",
               ticket,
               ". Error: ",
               GetLastError());

         continue;
        }

      string currency1;
      string currency2;

      if(!GetSymbolNewsCurrencies(symbol,
                                  currency1,
                                  currency2))
         continue;

      SNewsPositionMatch match;

      match.ticket = ticket;
      match.symbol = symbol;
      match.currency1 = currency1;
      match.currency2 = currency2;
      match.status = NEWS_POSITION_NOT_AFFECTED;
      match.protectionRequired = false;

      //--- Classify the position against the selected event currency
      if(currency1 == "" &&
         currency2 == "")
        {
         match.status = NEWS_POSITION_UNSUPPORTED;
        }
      else
         if(currency1 == g_newsState.eventCurrency ||
            currency2 == g_newsState.eventCurrency)
           {
            match.status = NEWS_POSITION_AFFECTED;
           }

      int currentSize = ArraySize(g_newsPositionMatches);

      //--- Store the ticket-level classification
      if(ArrayResize(g_newsPositionMatches,
                     currentSize + 1) != currentSize + 1)
        {
         Print("Prop Firm Guard: Could not expand news position match array.");

         return;
        }

      g_newsPositionMatches[currentSize] = match;
     }
  }

//+------------------------------------------------------------------+
//| Evaluate news holding rules                                      |
//+------------------------------------------------------------------+
void EvaluateNewsHoldingRules()
  {
//--- Reset the account-level holding result
   g_newsState.affectedPositions = 0;
   g_newsState.protectionPositions = 0;
   g_newsState.holdingStatus = NEWS_HOLDING_CLEAR;

   int totalMatches = ArraySize(g_newsPositionMatches);

//--- Stop when no selected event or classified positions exist
   if(!g_newsState.eventFound ||
      totalMatches == 0)
      return;

//--- Count positions affected by the selected event
   for(int i = 0; i < totalMatches; i++)
     {
      g_newsPositionMatches[i].protectionRequired = false;

      if(g_newsPositionMatches[i].status == NEWS_POSITION_AFFECTED)
         g_newsState.affectedPositions++;
     }

//--- No affected positions means no holding restriction applies
   if(g_newsState.affectedPositions == 0)
      return;

//--- Respect configurations that permit positions to remain open
   if(InpAllowNewsHolding)
     {
      if(g_newsState.restrictedWindow)
         g_newsState.holdingStatus = NEWS_HOLDING_ALLOWED;
      else
         g_newsState.holdingStatus = NEWS_HOLDING_WARNING;

      return;
     }

//--- Warn while affected positions approach the restricted window
   if(!g_newsState.restrictedWindow)
     {
      g_newsState.holdingStatus = NEWS_HOLDING_WARNING;

      return;
     }

//--- Mark affected positions when holding is prohibited in the window
   for(int i = 0; i < totalMatches; i++)
     {
      if(g_newsPositionMatches[i].status != NEWS_POSITION_AFFECTED)
         continue;

      g_newsPositionMatches[i].protectionRequired = true;
      g_newsState.protectionPositions++;
     }

   g_newsState.holdingStatus = NEWS_HOLDING_PROTECTION;
  }

//+------------------------------------------------------------------+
//| Update news position matches                                     |
//+------------------------------------------------------------------+
void UpdateNewsPositionMatches()
  {
//--- Classify all currently open positions against the selected event
   MatchOpenPositionsToNews();

//--- Apply the configured holding rule to those classifications
   EvaluateNewsHoldingRules();
  }

//+------------------------------------------------------------------+
//| Add currencies exposed by position symbol                        |
//+------------------------------------------------------------------+
bool AddPositionCurrencies(const string symbol,
                           string &currencies[])
  {
   string currency1;
   string currency2;

//--- Determine the supported news currencies for the position symbol
   if(!GetSymbolNewsCurrencies(symbol,
                               currency1,
                               currency2))
      return(false);

//--- Ignore instruments outside the supported monitoring scope
   if(currency1 == "" &&
      currency2 == "")
      return(true);

//--- Add the exposed currencies without creating duplicates
   if(!AddUniqueCurrency(currencies, currency1))
      return(false);

   if(!AddUniqueCurrency(currencies, currency2))
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Collect currencies from active positions                         |
//+------------------------------------------------------------------+
bool CollectExposureCurrencies(string &currencies[])
  {
//--- Start each collection with an empty exposure set
   ArrayResize(currencies, 0);

   int totalPositions = PositionsTotal();

//--- No open positions means there is currently no news exposure
   if(totalPositions == 0)
      return(true);

//--- Inspect every currently open account position
   for(int i = 0; i < totalPositions; i++)
     {
      ResetLastError();

      string symbol = PositionGetSymbol(i);

      if(symbol == "")
        {
         Print("Prop Firm Guard: Could not retrieve position symbol at index ",
               i,
               ". Error: ",
               GetLastError());

         return(false);
        }

      if(!AddPositionCurrencies(symbol, currencies))
         return(false);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Build monitored currency list                                    |
//+------------------------------------------------------------------+
string BuildCurrencyList(const string &currencies[])
  {
   string result = "";
   int count = ArraySize(currencies);

//--- Append each currency using a comma-separated format
   for(int i = 0; i < count; i++)
     {
      if(i > 0)
         result += ", ";

      result += currencies[i];
     }

   return(result);
  }

//+------------------------------------------------------------------+
//| Find next news event for currency                                |
//+------------------------------------------------------------------+
bool FindNextNewsForCurrency(const string       currency,
                             const datetime     timeFrom,
                             const datetime     timeTo,
                             MqlCalendarValue  &bestValue,
                             MqlCalendarEvent  &bestEvent)
  {
   MqlCalendarValue values[];

   ResetLastError();

//--- Request calendar values for the specified currency and time range
   int valueCount = CalendarValueHistory(values,
                                         timeFrom,
                                         timeTo,
                                         NULL,
                                         currency);

   if(valueCount < 0)
     {
      Print("Prop Firm Guard: Could not retrieve calendar values for ",
            currency,
            ". Error: ",
            GetLastError());

      return(false);
     }

   bool eventFound = false;
   datetime earliestTime = 0;

//--- Inspect the calendar values returned for this currency
   for(int i = 0; i < valueCount; i++)
     {
      MqlCalendarEvent event;

      ResetLastError();

      if(!CalendarEventById(values[i].event_id,
                            event))
        {
         Print("Prop Firm Guard: Could not retrieve calendar event ",
               values[i].event_id,
               ". Error: ",
               GetLastError());

         continue;
        }

      //--- Reject events below the configured minimum importance
      if(event.importance < InpNewsImportance)
         continue;

      //--- Require a calendar event with an exact release time
      if(event.time_mode != CALENDAR_TIMEMODE_DATETIME)
         continue;

      //--- Keep the earliest qualifying event in the search interval
      if(!eventFound ||
         values[i].time < earliestTime)
        {
         bestValue = values[i];
         bestEvent = event;
         earliestTime = values[i].time;
         eventFound = true;
        }
     }

   return(eventFound);
  }

//+------------------------------------------------------------------+
//| Update news state                                                |
//+------------------------------------------------------------------+
void UpdateNewsState()
  {
//--- Clear the previous exposure and event state
   InitializeNewsState();

//--- Stop immediately when economic-news monitoring is disabled
   if(!InpEnableNewsFilter)
     {
      g_newsState.status = NEWS_DISABLED;

      return;
     }

   string currencies[];

//--- Collect one unique currency set from all supported open positions
   if(!CollectExposureCurrencies(currencies))
     {
      g_newsState.status = NEWS_UNAVAILABLE;

      return;
     }

   int currencyCount = ArraySize(currencies);

//--- No supported exposure means there is nothing to search
   if(currencyCount == 0)
     {
      g_newsState.hasExposure = false;
      g_newsState.monitoredCurrencies = 0;
      g_newsState.currencyList = "";
      g_newsState.status = NEWS_NO_EXPOSURE;

      return;
     }

//--- Store the current account-exposure summary
   g_newsState.hasExposure = true;
   g_newsState.monitoredCurrencies = currencyCount;
   g_newsState.currencyList = BuildCurrencyList(currencies);

//--- Use trade-server time for calendar and restriction calculations
   datetime currentTime = TimeTradeServer();

   datetime searchFrom =
      currentTime -
      InpMinutesAfterNews * 60;

   datetime searchTo =
      currentTime +
      24 * 60 * 60;

   bool foundAny = false;

   ulong selectedEventId = 0;
   string selectedEventName = "";
   string selectedCurrency = "";
   ENUM_CALENDAR_EVENT_IMPORTANCE selectedImportance =
      CALENDAR_IMPORTANCE_NONE;
   datetime selectedEventTime = 0;

//--- Search each exposed currency and retain the nearest event
   for(int i = 0; i < currencyCount; i++)
     {
      MqlCalendarValue candidateValue;
      MqlCalendarEvent candidateEvent;

      if(!FindNextNewsForCurrency(currencies[i],
                                  searchFrom,
                                  searchTo,
                                  candidateValue,
                                  candidateEvent))
         continue;

      if(!foundAny ||
         candidateValue.time < selectedEventTime)
        {
         selectedEventId = candidateEvent.id;
         selectedEventName = candidateEvent.name;
         selectedCurrency = currencies[i];
         selectedImportance = candidateEvent.importance;
         selectedEventTime = candidateValue.time;
         foundAny = true;
        }
     }

//--- Report an exposed account with no qualifying event
   if(!foundAny)
     {
      g_newsState.status = NEWS_NO_EVENT;

      return;
     }

//--- Store the nearest qualifying event across all exposed currencies
   g_newsState.eventFound = true;
   g_newsState.eventCurrency = selectedCurrency;
   g_newsState.eventId = selectedEventId;
   g_newsState.eventName = selectedEventName;
   g_newsState.importance = selectedImportance;
   g_newsState.eventTime = selectedEventTime;

//--- Calculate the signed distance from the current server time
   g_newsState.secondsToEvent =
      (long)(g_newsState.eventTime - currentTime);

//--- Build the configured restriction interval
   g_newsState.restrictionStart =
      g_newsState.eventTime -
      InpMinutesBeforeNews * 60;

   g_newsState.restrictionEnd =
      g_newsState.eventTime +
      InpMinutesAfterNews * 60;

//--- Determine whether the current time is inside that interval
   g_newsState.restrictedWindow =
      (currentTime >= g_newsState.restrictionStart &&
       currentTime <= g_newsState.restrictionEnd);

   if(g_newsState.restrictedWindow)
      g_newsState.status = NEWS_RESTRICTED;
   else
      g_newsState.status = NEWS_SAFE;
  }

//+------------------------------------------------------------------+
//| Format news countdown                                            |
//+------------------------------------------------------------------+
string FormatNewsCountdown(const long secondsToEvent)
  {
   long absoluteSeconds = secondsToEvent;

//--- Convert the signed value into a duration for formatting
   if(absoluteSeconds < 0)
      absoluteSeconds = -absoluteSeconds;

   int hours = (int)(absoluteSeconds / 3600);
   int minutes = (int)((absoluteSeconds % 3600) / 60);
   int seconds = (int)(absoluteSeconds % 60);

   string formatted =
      StringFormat("%02d:%02d:%02d",
                   hours,
                   minutes,
                   seconds);

//--- Prefix elapsed post-event time with a plus sign
   if(secondsToEvent >= 0)
      return(formatted);

   return("+" + formatted);
  }

//+------------------------------------------------------------------+
//| Get trading date                                                 |
//+------------------------------------------------------------------+
string GetTradingDate()
  {
//--- Build the session date from trading-server time
   datetime serverTime = TimeCurrent();

   return(TimeToString(serverTime, TIME_DATE));
  }

//+------------------------------------------------------------------+
//| Open database                                                    |
//+------------------------------------------------------------------+
bool OpenDatabase()
  {
//--- Open or create the SQLite database
   ResetLastError();

   g_database = DatabaseOpen(g_databaseName,
                             DATABASE_OPEN_READWRITE |
                             DATABASE_OPEN_CREATE);

   if(g_database == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not open database ",
            g_databaseName,
            ". Error: ",
            GetLastError());

      return(false);
     }

   Print("Prop Firm Guard: Database opened successfully: ",
         g_databaseName);

   return(true);
  }

//+------------------------------------------------------------------+
//| Close database                                                   |
//+------------------------------------------------------------------+
void CloseDatabase()
  {
//--- Ignore the request when no database connection is active
   if(g_database == INVALID_HANDLE)
      return;

//--- Close the active SQLite connection
   ResetLastError();

   DatabaseClose(g_database);

   int errorCode = GetLastError();

   if(errorCode != 0)
     {
      Print("Prop Firm Guard: Database close reported error: ",
            errorCode);
     }
   else
     {
      Print("Prop Firm Guard: Database closed successfully.");
     }

//--- Clear the stored database handle
   g_database = INVALID_HANDLE;
  }

//+------------------------------------------------------------------+
//| Check whether database column exists                             |
//+------------------------------------------------------------------+
bool DatabaseColumnExists(const string tableName,
                          const string columnName)
  {
//--- Inspect the current table schema
   string sql = "PRAGMA table_info(" + tableName + ");";

   ResetLastError();

   int request = DatabasePrepare(g_database,
                                 sql);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not inspect table ",
            tableName,
            ". Error: ",
            GetLastError());

      return(false);
     }

   bool columnFound = false;

//--- Search the returned schema rows for the requested column
   while(true)
     {
      ResetLastError();

      if(!DatabaseRead(request))
        {
         int errorCode = GetLastError();

         if(errorCode != ERR_DATABASE_NO_MORE_DATA)
           {
            Print("Prop Firm Guard: Could not read schema for ",
                  tableName,
                  ". Error: ",
                  errorCode);
           }

         break;
        }

      string currentColumn;

      //--- PRAGMA table_info returns the column name at index 1
      if(!DatabaseColumnText(request,
                             1,
                             currentColumn))
        {
         Print("Prop Firm Guard: Could not read database column name. Error: ",
               GetLastError());

         break;
        }

      if(currentColumn == columnName)
        {
         columnFound = true;

         break;
        }
     }

//--- Release the schema request
   FinalizeDatabaseRequest(request);

   return(columnFound);
  }

//+------------------------------------------------------------------+
//| Ensure database column exists                                    |
//+------------------------------------------------------------------+
bool EnsureDatabaseColumn(const string tableName,
                          const string columnName,
                          const string columnDefinition)
  {
//--- Leave an existing column unchanged
   if(DatabaseColumnExists(tableName,
                           columnName))
      return(true);

//--- Add the missing column
   string sql =
      "ALTER TABLE " +
      tableName +
      " ADD COLUMN " +
      columnName +
      " " +
      columnDefinition +
      ";";

   ResetLastError();

   if(!DatabaseExecute(g_database,
                       sql))
     {
      Print("Prop Firm Guard: Could not add column ",
            columnName,
            " to ",
            tableName,
            ". Error: ",
            GetLastError());

      return(false);
     }

   Print("Prop Firm Guard: Added database column ",
         tableName,
         ".",
         columnName,
         ".");

   return(true);
  }

//+------------------------------------------------------------------+
//| Ensure runtime daily-session columns exist                       |
//+------------------------------------------------------------------+
bool EnsureDailySessionRuntimeColumns()
  {
//--- Add runtime persistence columns when missing
   if(!EnsureDatabaseColumn("daily_sessions",
                            "latest_balance",
                            "REAL NOT NULL DEFAULT 0"))
      return(false);

   if(!EnsureDatabaseColumn("daily_sessions",
                            "latest_equity",
                            "REAL NOT NULL DEFAULT 0"))
      return(false);

   if(!EnsureDatabaseColumn("daily_sessions",
                            "daily_loss",
                            "REAL NOT NULL DEFAULT 0"))
      return(false);

   if(!EnsureDatabaseColumn("daily_sessions",
                            "maximum_daily_loss_reached",
                            "REAL NOT NULL DEFAULT 0"))
      return(false);

   if(!EnsureDatabaseColumn("daily_sessions",
                            "target_progress",
                            "REAL NOT NULL DEFAULT 0"))
      return(false);

   if(!EnsureDatabaseColumn("daily_sessions",
                            "session_status",
                            "TEXT NOT NULL DEFAULT 'AWAITING_CONFIRMATION'"))
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Ensure database tables exist                                     |
//+------------------------------------------------------------------+
bool EnsureDatabaseTables()
  {
//--- Define account-level settings storage
   string settingsTable =
      "CREATE TABLE IF NOT EXISTS settings ("
      "account_login INTEGER NOT NULL,"
      "account_server TEXT NOT NULL,"
      "initial_balance REAL NOT NULL,"
      "daily_drawdown_percent REAL NOT NULL,"
      "overall_drawdown_percent REAL NOT NULL,"
      "profit_target_percent REAL NOT NULL,"
      "updated_at INTEGER NOT NULL,"
      "PRIMARY KEY(account_login, account_server)"
      ");";

//--- Define persistent trading-day storage
   string dailySessionsTable =
      "CREATE TABLE IF NOT EXISTS daily_sessions ("
      "account_login INTEGER NOT NULL,"
      "account_server TEXT NOT NULL,"
      "trading_date TEXT NOT NULL,"
      "starting_balance REAL NOT NULL,"
      "starting_equity REAL NOT NULL,"
      "balance_confirmed INTEGER NOT NULL,"
      "latest_balance REAL NOT NULL DEFAULT 0,"
      "latest_equity REAL NOT NULL DEFAULT 0,"
      "daily_loss REAL NOT NULL DEFAULT 0,"
      "maximum_daily_loss_reached REAL NOT NULL DEFAULT 0,"
      "target_progress REAL NOT NULL DEFAULT 0,"
      "session_status TEXT NOT NULL DEFAULT 'AWAITING_CONFIRMATION',"
      "created_at INTEGER NOT NULL,"
      "updated_at INTEGER NOT NULL,"
      "PRIMARY KEY(account_login, account_server, trading_date)"
      ");";

//--- Ensure the account settings table exists
   ResetLastError();

   if(!DatabaseExecute(g_database,
                       settingsTable))
     {
      Print("Prop Firm Guard: Could not create settings table. Error: ",
            GetLastError());

      return(false);
     }

//--- Ensure the daily-session table exists
   ResetLastError();

   if(!DatabaseExecute(g_database,
                       dailySessionsTable))
     {
      Print("Prop Firm Guard: Could not create daily_sessions table. Error: ",
            GetLastError());

      return(false);
     }

//--- Extend an existing daily-session table when required
   if(!EnsureDailySessionRuntimeColumns())
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Check for new trading day                                        |
//+------------------------------------------------------------------+
void CheckForNewTradingDay()
  {
//--- Read the current server-based trading date
   string currentDate = GetTradingDate();

//--- Keep the active session when it already belongs to today
   if(g_hasDailySession &&
      g_dailySession.tradingDate == currentDate)
      return;

   Print("Prop Firm Guard: New trading day detected: ",
         currentDate);

//--- Restore or create the session for the new trading date
   if(!InitializeDailySession())
     {
      Print("Prop Firm Guard: Could not initialize the new daily session.");

      return;
     }

//--- Rebuild the confirmation controls for the newly loaded session
   DeleteDailySessionControls();

   if(!CreateDailySessionControls())
     {
      Print("Prop Firm Guard: Could not create daily session controls.");
     }
  }

//+------------------------------------------------------------------+
//| Finalize database request                                        |
//+------------------------------------------------------------------+
void FinalizeDatabaseRequest(const int request)
  {
//--- Ignore invalid database requests
   if(request == INVALID_HANDLE)
      return;

//--- Release the prepared database request
   ResetLastError();

   DatabaseFinalize(request);

   int errorCode = GetLastError();

   if(errorCode != 0)
     {
      Print("Prop Firm Guard: Could not finalize database request. Error: ",
            errorCode);
     }
  }

//+------------------------------------------------------------------+
//| Execute prepared database statement                              |
//+------------------------------------------------------------------+
bool ExecuteDatabaseRequest(const int request,
                            const string operation)
  {
//--- Execute the prepared database statement
   ResetLastError();

   bool result = DatabaseRead(request);

   int errorCode = GetLastError();

//--- Accept normal completion when no result row is returned
   bool success =
      (result || errorCode == ERR_DATABASE_NO_MORE_DATA);

   if(!success)
     {
      Print("Prop Firm Guard: Database error while ",
            operation,
            ". Error: ",
            errorCode);
     }

//--- Release the request after execution
   FinalizeDatabaseRequest(request);

   return(success);
  }

//+------------------------------------------------------------------+
//| Save account settings                                            |
//+------------------------------------------------------------------+
bool SaveAccountSettings()
  {
//--- Prepare the account-settings write statement
   string sql =
      "INSERT OR REPLACE INTO settings ("
      "account_login,"
      "account_server,"
      "initial_balance,"
      "daily_drawdown_percent,"
      "overall_drawdown_percent,"
      "profit_target_percent,"
      "updated_at"
      ") VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7);";

   int request = DatabasePrepare(g_database, sql);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not prepare settings save request. Error: ",
            GetLastError());

      return(false);
     }

//--- Bind the current account settings to the prepared statement
   if(!DatabaseBind(request, 0, g_accountSettings.accountLogin) ||
      !DatabaseBind(request, 1, g_accountSettings.accountServer) ||
      !DatabaseBind(request, 2, g_accountSettings.initialBalance) ||
      !DatabaseBind(request, 3, g_accountSettings.dailyDrawdownPercent) ||
      !DatabaseBind(request, 4, g_accountSettings.overallDrawdownPercent) ||
      !DatabaseBind(request, 5, g_accountSettings.profitTargetPercent) ||
      !DatabaseBind(request, 6, g_accountSettings.updatedAt))
     {
      Print("Prop Firm Guard: Could not bind settings values. Error: ",
            GetLastError());

      FinalizeDatabaseRequest(request);
      return(false);
     }

//--- Execute and finalize the prepared write request
   if(!ExecuteDatabaseRequest(request, "saving account settings"))
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Load account settings                                            |
//+------------------------------------------------------------------+
bool LoadAccountSettings()
  {
//--- Build the current account/server lookup
   string accountServer = AccountInfoString(ACCOUNT_SERVER);

   string sql =
      "SELECT "
      "account_login,"
      "account_server,"
      "initial_balance,"
      "daily_drawdown_percent,"
      "overall_drawdown_percent,"
      "profit_target_percent,"
      "updated_at "
      "FROM settings "
      "WHERE account_login = ?1 AND account_server = ?2;";

   int request = DatabasePrepare(g_database, sql);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not prepare settings load request. Error: ",
            GetLastError());

      return(false);
     }

//--- Bind the current account identity
   if(!DatabaseBind(request, 0, g_accountState.login) ||
      !DatabaseBind(request, 1, accountServer))
     {
      Print("Prop Firm Guard: Could not bind settings search values. Error: ",
            GetLastError());

      FinalizeDatabaseRequest(request);
      return(false);
     }

//--- Read the matching settings record
   ResetLastError();

   if(!DatabaseRead(request))
     {
      int errorCode = GetLastError();

      FinalizeDatabaseRequest(request);

      //--- No row means this account/server pair has not been saved yet
      if(errorCode == ERR_DATABASE_NO_MORE_DATA)
         return(false);

      Print("Prop Firm Guard: Could not read account settings. Error: ",
            errorCode);

      return(false);
     }

//--- Read and validate the stored column values
   long   accountLogin;
   string storedServer;
   double initialBalance;
   double dailyDrawdown;
   double overallDrawdown;
   double profitTarget;
   long   updatedAt;

   if(!DatabaseColumnLong(request, 0, accountLogin) ||
      !DatabaseColumnText(request, 1, storedServer) ||
      !DatabaseColumnDouble(request, 2, initialBalance) ||
      !DatabaseColumnDouble(request, 3, dailyDrawdown) ||
      !DatabaseColumnDouble(request, 4, overallDrawdown) ||
      !DatabaseColumnDouble(request, 5, profitTarget) ||
      !DatabaseColumnLong(request, 6, updatedAt))
     {
      Print("Prop Firm Guard: Could not read stored settings columns. Error: ",
            GetLastError());

      FinalizeDatabaseRequest(request);
      return(false);
     }

//--- Restore the stored values into the account settings structure
   g_accountSettings.accountLogin           = accountLogin;
   g_accountSettings.accountServer          = storedServer;
   g_accountSettings.initialBalance         = initialBalance;
   g_accountSettings.dailyDrawdownPercent   = dailyDrawdown;
   g_accountSettings.overallDrawdownPercent = overallDrawdown;
   g_accountSettings.profitTargetPercent    = profitTarget;
   g_accountSettings.updatedAt              = (datetime)updatedAt;

//--- Release the completed read request
   FinalizeDatabaseRequest(request);

   return(true);
  }

//+------------------------------------------------------------------+
//| Initialize daily session                                         |
//+------------------------------------------------------------------+
bool InitializeDailySession()
  {
//--- Identify the current trading day
   string tradingDate = GetTradingDate();

//--- Restore today's session when it already exists
   if(DailySessionExists(tradingDate))
     {
      if(!LoadDailySession())
         return(false);

      g_hasDailySession = true;

      Print("Prop Firm Guard: Daily session restored for ",
            tradingDate,
            ".");

      return(true);
     }

//--- Create a new unconfirmed session for the current trading day
   g_dailySession.accountLogin = g_accountState.login;
   g_dailySession.accountServer = AccountInfoString(ACCOUNT_SERVER);
   g_dailySession.tradingDate = tradingDate;
   g_dailySession.startingBalance = 0.0;
   g_dailySession.startingEquity = 0.0;
   g_dailySession.balanceConfirmed = false;
   g_dailySession.latestBalance = g_accountState.balance;
   g_dailySession.latestEquity = g_accountState.equity;
   g_dailySession.dailyLoss = 0.0;
   g_dailySession.maximumDailyLossReached = 0.0;
   g_dailySession.targetProgress = 0.0;
   g_dailySession.sessionStatus = "AWAITING_CONFIRMATION";
   g_dailySession.createdAt = TimeCurrent();
   g_dailySession.updatedAt = TimeCurrent();

//--- Persist the new daily-session record
   if(!SaveDailySession())
      return(false);

   g_hasDailySession = true;

   Print("Prop Firm Guard: New daily session created for ",
         tradingDate,
         ".");

   return(true);
  }

//+------------------------------------------------------------------+
//| Initialize account settings                                      |
//+------------------------------------------------------------------+
bool InitializeAccountSettings()
  {
//--- Check whether this account/server pair already has stored settings
   bool settingsFound = LoadAccountSettings();

//--- Associate the settings with the current trading account
   g_accountSettings.accountLogin = g_accountState.login;
   g_accountSettings.accountServer = AccountInfoString(ACCOUNT_SERVER);

//--- Synchronize persistence with the current Inputs values
   g_accountSettings.initialBalance = InpInitialAccountBalance;
   g_accountSettings.dailyDrawdownPercent = InpDailyDrawdownPercent;
   g_accountSettings.overallDrawdownPercent = InpOverallDrawdownPercent;
   g_accountSettings.profitTargetPercent = InpProfitTargetPercent;
   g_accountSettings.updatedAt = TimeCurrent();

//--- Save the synchronized configuration
   if(!SaveAccountSettings())
      return(false);

//--- Report whether the record was created or synchronized
   if(settingsFound)
      Print("Prop Firm Guard: Account settings restored and synchronized.");
   else
      Print("Prop Firm Guard: New account settings saved.");

   return(true);
  }

//+------------------------------------------------------------------+
//| Save daily session                                               |
//+------------------------------------------------------------------+
bool SaveDailySession()
  {
//--- Prepare the complete daily-session record
   string sql =
      "INSERT OR REPLACE INTO daily_sessions ("
      "account_login,"
      "account_server,"
      "trading_date,"
      "starting_balance,"
      "starting_equity,"
      "balance_confirmed,"
      "latest_balance,"
      "latest_equity,"
      "daily_loss,"
      "maximum_daily_loss_reached,"
      "target_progress,"
      "session_status,"
      "created_at,"
      "updated_at"
      ") VALUES ("
      "?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14"
      ");";

   ResetLastError();

   int request = DatabasePrepare(g_database,
                                 sql,
                                 g_dailySession.accountLogin,
                                 g_dailySession.accountServer,
                                 g_dailySession.tradingDate,
                                 g_dailySession.startingBalance,
                                 g_dailySession.startingEquity,
                                 g_dailySession.balanceConfirmed ? 1 : 0,
                                 g_dailySession.latestBalance,
                                 g_dailySession.latestEquity,
                                 g_dailySession.dailyLoss,
                                 g_dailySession.maximumDailyLossReached,
                                 g_dailySession.targetProgress,
                                 g_dailySession.sessionStatus,
                                 (long)g_dailySession.createdAt,
                                 (long)g_dailySession.updatedAt);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not prepare daily session save request. Error: ",
            GetLastError());

      return(false);
     }

//--- Execute and finalize the prepared write request
   return(ExecuteDatabaseRequest(request,
                                 "saving daily session"));
  }

//+------------------------------------------------------------------+
//| Load daily session                                               |
//+------------------------------------------------------------------+
bool LoadDailySession()
  {
//--- Select the session belonging to the current account and date
   string sql =
      "SELECT "
      "account_login,"
      "account_server,"
      "trading_date,"
      "starting_balance,"
      "starting_equity,"
      "balance_confirmed,"
      "latest_balance,"
      "latest_equity,"
      "daily_loss,"
      "maximum_daily_loss_reached,"
      "target_progress,"
      "session_status,"
      "created_at,"
      "updated_at "
      "FROM daily_sessions "
      "WHERE account_login=?1 "
      "AND account_server=?2 "
      "AND trading_date=?3;";

   string tradingDate = GetTradingDate();
   string accountServer = AccountInfoString(ACCOUNT_SERVER);

   ResetLastError();

   int request = DatabasePrepare(g_database,
                                 sql,
                                 g_accountState.login,
                                 accountServer,
                                 tradingDate);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not prepare daily session load request. Error: ",
            GetLastError());

      return(false);
     }

//--- Read the matching record
   ResetLastError();

   if(!DatabaseRead(request))
     {
      int errorCode = GetLastError();

      if(errorCode != ERR_DATABASE_NO_MORE_DATA)
        {
         Print("Prop Firm Guard: Could not load daily session. Error: ",
               errorCode);
        }

      FinalizeDatabaseRequest(request);

      return(false);
     }

//--- Read all stored values before updating the in-memory session
   long accountLogin;
   string loadedServer;
   string loadedDate;
   double startingBalance;
   double startingEquity;
   int balanceConfirmed;
   double latestBalance;
   double latestEquity;
   double dailyLoss;
   double maximumDailyLossReached;
   double targetProgress;
   string sessionStatus;
   long createdAt;
   long updatedAt;

   bool loaded =
      DatabaseColumnLong(request, 0, accountLogin) &&
      DatabaseColumnText(request, 1, loadedServer) &&
      DatabaseColumnText(request, 2, loadedDate) &&
      DatabaseColumnDouble(request, 3, startingBalance) &&
      DatabaseColumnDouble(request, 4, startingEquity) &&
      DatabaseColumnInteger(request, 5, balanceConfirmed) &&
      DatabaseColumnDouble(request, 6, latestBalance) &&
      DatabaseColumnDouble(request, 7, latestEquity) &&
      DatabaseColumnDouble(request, 8, dailyLoss) &&
      DatabaseColumnDouble(request, 9, maximumDailyLossReached) &&
      DatabaseColumnDouble(request, 10, targetProgress) &&
      DatabaseColumnText(request, 11, sessionStatus) &&
      DatabaseColumnLong(request, 12, createdAt) &&
      DatabaseColumnLong(request, 13, updatedAt);

   if(!loaded)
     {
      Print("Prop Firm Guard: Could not read daily session columns. Error: ",
            GetLastError());

      FinalizeDatabaseRequest(request);

      return(false);
     }

//--- Restore the complete daily-session state
   g_dailySession.accountLogin = accountLogin;
   g_dailySession.accountServer = loadedServer;
   g_dailySession.tradingDate = loadedDate;
   g_dailySession.startingBalance = startingBalance;
   g_dailySession.startingEquity = startingEquity;
   g_dailySession.balanceConfirmed = (balanceConfirmed != 0);
   g_dailySession.latestBalance = latestBalance;
   g_dailySession.latestEquity = latestEquity;
   g_dailySession.dailyLoss = dailyLoss;
   g_dailySession.maximumDailyLossReached = maximumDailyLossReached;
   g_dailySession.targetProgress = targetProgress;
   g_dailySession.sessionStatus = sessionStatus;
   g_dailySession.createdAt = (datetime)createdAt;
   g_dailySession.updatedAt = (datetime)updatedAt;

//--- Release the completed read request
   FinalizeDatabaseRequest(request);

   return(true);
  }

//+------------------------------------------------------------------+
//| Check daily session existence                                    |
//+------------------------------------------------------------------+
bool DailySessionExists(const string tradingDate)
  {
//--- Build the session identity for the requested trading date
   string accountServer = AccountInfoString(ACCOUNT_SERVER);

   string sql =
      "SELECT 1 "
      "FROM daily_sessions "
      "WHERE account_login = ?1 "
      "AND account_server = ?2 "
      "AND trading_date = ?3 "
      "LIMIT 1;";

   int request = DatabasePrepare(g_database, sql);

   if(request == INVALID_HANDLE)
     {
      Print("Prop Firm Guard: Could not prepare session existence request. Error: ",
            GetLastError());

      return(false);
     }

//--- Bind the current account, server, and requested date
   if(!DatabaseBind(request, 0, g_accountState.login) ||
      !DatabaseBind(request, 1, accountServer) ||
      !DatabaseBind(request, 2, tradingDate))
     {
      Print("Prop Firm Guard: Could not bind session existence values. Error: ",
            GetLastError());

      FinalizeDatabaseRequest(request);
      return(false);
     }

//--- Check whether one matching row exists
   ResetLastError();

   bool exists = DatabaseRead(request);

   int errorCode = GetLastError();

   FinalizeDatabaseRequest(request);

   if(!exists && errorCode != ERR_DATABASE_NO_MORE_DATA)
     {
      Print("Prop Firm Guard: Could not check daily session existence. Error: ",
            errorCode);
     }

   return(exists);
  }

//+------------------------------------------------------------------+
//| Create starting balance edit                                     |
//+------------------------------------------------------------------+
bool CreateStartingBalanceEdit(const int    x,
                               const int    y,
                               const string suggestedBalance)
  {
//--- Create the editable starting-balance field
   if(!ObjectCreate(0,
                    g_startBalanceEdit,
                    OBJ_EDIT,
                    0,
                    0,
                    0))
     {
      Print("Prop Firm Guard: Could not create starting balance field. Error: ",
            GetLastError());

      return(false);
     }

//--- Configure the field position and appearance
   if(!ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_CORNER,
                        CORNER_LEFT_UPPER) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_XDISTANCE,
                        x) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_YDISTANCE,
                        y) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_XSIZE,
                        120) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_YSIZE,
                        20) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_FONTSIZE,
                        9) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_COLOR,
                        clrBlack) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_BGCOLOR,
                        clrWhite) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_BORDER_COLOR,
                        clrSilver) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_ALIGN,
                        ALIGN_RIGHT) ||
      !ObjectSetInteger(0,
                        g_startBalanceEdit,
                        OBJPROP_HIDDEN,
                        true))
     {
      Print("Prop Firm Guard: Could not configure starting balance field. Error: ",
            GetLastError());

      return(false);
     }

//--- Apply the suggested balance and text properties
   if(!ObjectSetString(0,
                       g_startBalanceEdit,
                       OBJPROP_FONT,
                       "Tahoma") ||
      !ObjectSetString(0,
                       g_startBalanceEdit,
                       OBJPROP_TEXT,
                       suggestedBalance))
     {
      Print("Prop Firm Guard: Could not initialize starting balance field. Error: ",
            GetLastError());

      return(false);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Create confirm balance button                                    |
//+------------------------------------------------------------------+
bool CreateConfirmBalanceButton(const int x,
                                const int y)
  {
//--- Create the daily-balance confirmation button
   if(!ObjectCreate(0,
                    g_confirmButton,
                    OBJ_BUTTON,
                    0,
                    0,
                    0))
     {
      Print("Prop Firm Guard: Could not create confirmation button. Error: ",
            GetLastError());

      return(false);
     }

//--- Configure the button position and appearance
   if(!ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_CORNER,
                        CORNER_LEFT_UPPER) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_XDISTANCE,
                        x) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_YDISTANCE,
                        y) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_XSIZE,
                        100) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_YSIZE,
                        20) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_FONTSIZE,
                        9) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_COLOR,
                        clrBlack) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_BGCOLOR,
                        clrWhite) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_BORDER_COLOR,
                        clrSilver) ||
      !ObjectSetInteger(0,
                        g_confirmButton,
                        OBJPROP_HIDDEN,
                        true))
     {
      Print("Prop Firm Guard: Could not configure confirmation button. Error: ",
            GetLastError());

      return(false);
     }

//--- Apply the button text and font
   if(!ObjectSetString(0,
                       g_confirmButton,
                       OBJPROP_FONT,
                       "Tahoma") ||
      !ObjectSetString(0,
                       g_confirmButton,
                       OBJPROP_TEXT,
                       "Confirm"))
     {
      Print("Prop Firm Guard: Could not initialize confirmation button. Error: ",
            GetLastError());

      return(false);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Create daily session controls                                    |
//+------------------------------------------------------------------+
bool CreateDailySessionControls()
  {
//--- Skip the controls when today's balance is already confirmed
   if(g_dailySession.balanceConfirmed)
      return(true);

   int controlX = InpDashboardX + 18;
   int controlY = InpDashboardY + 120;

//--- Suggest the current balance without confirming it
   string suggestedBalance =
      DoubleToString(g_accountState.balance, 2);

//--- Create the editable starting-balance field
   if(!CreateStartingBalanceEdit(controlX,
                                 controlY,
                                 suggestedBalance))
      return(false);

//--- Create the confirmation button beside the edit field
   if(!CreateConfirmBalanceButton(controlX + 130,
                                  controlY))
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Delete daily session controls                                    |
//+------------------------------------------------------------------+
void DeleteDailySessionControls()
  {
//--- Remove the starting-balance field when present
   if(ObjectFind(0, g_startBalanceEdit) >= 0)
     {
      if(!ObjectDelete(0, g_startBalanceEdit))
        {
         Print("Prop Firm Guard: Could not delete starting balance field. Error: ",
               GetLastError());
        }
     }

//--- Remove the confirmation button when present
   if(ObjectFind(0, g_confirmButton) >= 0)
     {
      if(!ObjectDelete(0, g_confirmButton))
        {
         Print("Prop Firm Guard: Could not delete confirmation button. Error: ",
               GetLastError());
        }
     }

   ChartRedraw();
  }

//+------------------------------------------------------------------+
//| Confirm daily starting balance                                   |
//+------------------------------------------------------------------+
bool ConfirmDailyStartingBalance()
  {
//--- Do not overwrite an already confirmed daily baseline
   if(g_dailySession.balanceConfirmed)
     {
      Print("Prop Firm Guard: Today's starting balance is already confirmed.");

      return(true);
     }

   string balanceText;

   ResetLastError();

//--- Read the value entered in the starting-balance field
   if(!ObjectGetString(0,
                       g_startBalanceEdit,
                       OBJPROP_TEXT,
                       0,
                       balanceText))
     {
      Print("Prop Firm Guard: Could not read starting balance field. Error: ",
            GetLastError());

      return(false);
     }

   double startingBalance = StringToDouble(balanceText);

//--- Reject an invalid daily starting balance
   if(startingBalance <= 0.0)
     {
      Alert("Prop Firm Guard: Enter a valid starting balance greater than zero.");

      return(false);
     }

//--- Store the confirmed daily reference
   g_dailySession.startingBalance  = startingBalance;
   g_dailySession.startingEquity   = g_accountState.equity;
   g_dailySession.balanceConfirmed = true;
   g_dailySession.updatedAt        = TimeCurrent();

//--- Persist the confirmed session immediately
   if(!SaveDailySession())
     {
      Print("Prop Firm Guard: Could not save confirmed daily session.");

      //--- Do not report a confirmed state that SQLite failed to preserve
      g_dailySession.balanceConfirmed = false;

      return(false);
     }

   Print("Prop Firm Guard: Daily starting balance confirmed at ",
         DoubleToString(g_dailySession.startingBalance, 2),
         " for ",
         g_dailySession.tradingDate,
         ".");

//--- Remove controls after the confirmed value has been stored
   DeleteDailySessionControls();

   return(true);
  }

//+------------------------------------------------------------------+
//| Convert compliance status to text                                |
//+------------------------------------------------------------------+
string ComplianceStatusToString(const ENUM_COMPLIANCE_STATUS status)
  {
   switch(status)
     {
      case COMPLIANCE_WARNING:
         return("WARNING");

      case COMPLIANCE_CRITICAL:
         return("CRITICAL");

      case COMPLIANCE_BREACHED:
         return("BREACHED");

      case COMPLIANCE_SAFE:
      default:
         return("SAFE");
     }
  }

//+------------------------------------------------------------------+
//| Convert target status to text                                    |
//+------------------------------------------------------------------+
string TargetStatusToString(const ENUM_TARGET_STATUS status)
  {
   switch(status)
     {
      case TARGET_NEARING:
         return("NEARING TARGET");

      case TARGET_REACHED:
         return("TARGET REACHED");

      case TARGET_IN_PROGRESS:
      default:
         return("IN PROGRESS");
     }
  }

//+------------------------------------------------------------------+
//| Get overall guard status                                         |
//+------------------------------------------------------------------+
ENUM_GUARD_STATUS GetOverallGuardStatus()
  {
//--- Give the highest priority to any drawdown breach
   if(g_dailyDrawdown.status == COMPLIANCE_BREACHED ||
      g_overallDrawdown.status == COMPLIANCE_BREACHED)
      return(GUARD_BREACHED);

//--- Check for a critical drawdown condition
   if(g_dailyDrawdown.status == COMPLIANCE_CRITICAL ||
      g_overallDrawdown.status == COMPLIANCE_CRITICAL)
      return(GUARD_CRITICAL);

//--- Check for a warning condition
   if(g_dailyDrawdown.status == COMPLIANCE_WARNING ||
      g_overallDrawdown.status == COMPLIANCE_WARNING)
      return(GUARD_WARNING);

//--- Report target completion only when no risk condition has priority
   if(g_profitTarget.status == TARGET_REACHED)
      return(GUARD_TARGET_REACHED);

   return(GUARD_SAFE);
  }

//+------------------------------------------------------------------+
//| Convert guard status to text                                     |
//+------------------------------------------------------------------+
string GuardStatusToString(const ENUM_GUARD_STATUS status)
  {
   switch(status)
     {
      case GUARD_BREACHED:
         return("BREACHED");

      case GUARD_CRITICAL:
         return("CRITICAL");

      case GUARD_WARNING:
         return("WARNING");

      case GUARD_TARGET_REACHED:
         return("TARGET REACHED");

      case GUARD_SAFE:
      default:
         return("SAFE");
     }
  }

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Validate the timer interval
   if(InpTimerSeconds < 1)
     {
      Print("Prop Firm Guard: Timer interval must be at least 1 second.");

      return(INIT_PARAMETERS_INCORRECT);
     }

//--- Validate the configured compliance inputs
   if(!ValidateComplianceInputs())
      return(INIT_PARAMETERS_INCORRECT);

//--- Use synchronous trade execution for protection actions
   g_trade.SetAsyncMode(false);

//--- Read the current account state
   UpdateAccountState();

//--- Open the SQLite database
   if(!OpenDatabase())
     {
      Print("Prop Firm Guard: Database initialization failed.");

      return(INIT_FAILED);
     }

//--- Ensure the required database tables exist
   if(!EnsureDatabaseTables())
     {
      Print("Prop Firm Guard: Could not initialize database tables.");

      CloseDatabase();

      return(INIT_FAILED);
     }

//--- Restore account-specific settings
   if(!InitializeAccountSettings())
     {
      Print("Prop Firm Guard: Could not initialize account settings.");

      CloseDatabase();

      return(INIT_FAILED);
     }

//--- Restore or create the current daily session
   if(!InitializeDailySession())
     {
      Print("Prop Firm Guard: Could not initialize daily session.");

      CloseDatabase();

      return(INIT_FAILED);
     }

//--- Calculate the initial financial compliance state
   CalculateDailyDrawdown();
   CalculateOverallDrawdown();
   CalculateProfitTarget();

//--- Calculate the initial economic-news state
   UpdateNewsState();

//--- Classify positions and evaluate the initial holding state
   UpdateNewsPositionMatches();

//--- Establish the initial alert baseline
   InitializeAlertState();

//--- Start periodic monitoring
   if(!EventSetTimer(InpTimerSeconds))
     {
      Print("Prop Firm Guard: Failed to start the timer. Error: ",
            GetLastError());

      CloseDatabase();

      return(INIT_FAILED);
     }

   Print("Prop Firm Guard initialized successfully.");

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Stop periodic events
   EventKillTimer();

//--- Remove daily-session controls
   DeleteDailySessionControls();

//--- Close the SQLite connection
   CloseDatabase();

   Print("Prop Firm Guard removed. Deinitialization reason: ", reason);
  }

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

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//--- Refresh the current account state
   UpdateAccountState();

//--- Maintain the current trading-day session
   CheckForNewTradingDay();

//--- Recalculate the financial compliance state
   CalculateDailyDrawdown();
   CalculateOverallDrawdown();
   CalculateProfitTarget();

//--- Refresh the account-level economic-news state
   UpdateNewsState();

//--- Refresh position matching and news-holding evaluation
   UpdateNewsPositionMatches();

//--- Process meaningful alert transitions
   ManageAlerts();

//--- Execute configured protection actions
   ManageProtectionActions();
  }

//+------------------------------------------------------------------+
//| Chart event function                                             |
//+------------------------------------------------------------------+
void OnChartEvent(const int    id,
                  const long   &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- Process chart-object clicks only
   if(id != CHARTEVENT_OBJECT_CLICK)
      return;

//--- Confirm the entered balance when the confirmation button is clicked
   if(sparam == g_confirmButton)
     {
      if(!ConfirmDailyStartingBalance())
         Print("Prop Firm Guard: Starting balance confirmation failed.");
     }
  }
  
//+------------------------------------------------------------------+
//| Check successful position-close return code                      |
//+------------------------------------------------------------------+
bool IsSuccessfulCloseRetcode(const uint retcode)
  {
//--- Accept only return codes that confirm complete closure
   if(retcode == TRADE_RETCODE_DONE ||
      retcode == TRADE_RETCODE_POSITION_CLOSED)
      return(true);

   return(false);
  }
  
//+------------------------------------------------------------------+
//| Close position by ticket                                         |
//+------------------------------------------------------------------+
bool ClosePositionByTicket(const ulong ticket,
                           const string reason)
  {
//--- Confirm that the position still exists
   ResetLastError();

   if(!PositionSelectByTicket(ticket))
     {
      int errorCode = GetLastError();

      Print("Prop Firm Guard: Position ",
            ticket,
            " is no longer available. Error: ",
            errorCode);

      return(true);
     }

   string symbol;

//--- Read the symbol associated with the selected ticket
   if(!PositionGetString(POSITION_SYMBOL,
                         symbol))
     {
      Print("Prop Firm Guard: Could not read symbol for position ",
            ticket,
            ". Error: ",
            GetLastError());

      return(false);
     }

//--- Use the filling policy supported by this symbol
   if(!g_trade.SetTypeFillingBySymbol(symbol))
     {
      Print("Prop Firm Guard: Could not determine filling policy for ",
            symbol,
            ".");

      return(false);
     }

//--- Submit the close request
   ResetLastError();

   bool requestAccepted = g_trade.PositionClose(ticket);

   uint retcode = g_trade.ResultRetcode();
   string retcodeDescription = g_trade.ResultRetcodeDescription();

   if(!requestAccepted)
     {
      Print("Prop Firm Guard: Close request failed for ticket ",
            ticket,
            " [",
            symbol,
            "]. Reason: ",
            reason,
            ". Retcode: ",
            retcode,
            " - ",
            retcodeDescription,
            ". Runtime error: ",
            GetLastError());

      return(false);
     }

//--- Require explicit trade-server confirmation of complete closure
   if(!IsSuccessfulCloseRetcode(retcode))
     {
      Print("Prop Firm Guard: Trade server did not confirm complete closure of ticket ",
            ticket,
            " [",
            symbol,
            "]. Reason: ",
            reason,
            ". Retcode: ",
            retcode,
            " - ",
            retcodeDescription);

      return(false);
     }

//--- Verify that the position no longer exists
   ResetLastError();

   if(PositionSelectByTicket(ticket))
     {
      Print("Prop Firm Guard: Position ",
            ticket,
            " [",
            symbol,
            "] still exists after close request.");

      return(false);
     }

   Print("Prop Firm Guard: Position ",
         ticket,
         " [",
         symbol,
         "] closed successfully. Reason: ",
         reason,
         ".");

   return(true);
  }
  
//+------------------------------------------------------------------+
//| Close all open positions                                         |
//+------------------------------------------------------------------+
bool CloseAllPositions(const string reason)
  {
   int totalPositions = PositionsTotal();

   if(totalPositions == 0)
      return(true);

   ulong tickets[];

//--- Allocate storage for the current position set
   if(ArrayResize(tickets, totalPositions) != totalPositions)
     {
      Print("Prop Firm Guard: Could not allocate position ticket array.");

      return(false);
     }

   int ticketCount = 0;

//--- Capture every open position ticket
   for(int i = 0; i < totalPositions; i++)
     {
      ResetLastError();

      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
        {
         Print("Prop Firm Guard: Could not retrieve position ticket at index ",
               i,
               ". Error: ",
               GetLastError());

         continue;
        }

      tickets[ticketCount] = ticket;
      ticketCount++;
     }

   bool allClosed = true;

//--- Close positions from the stable ticket list
   for(int i = 0; i < ticketCount; i++)
     {
      if(!ClosePositionByTicket(tickets[i],
                                reason))
         allClosed = false;
     }

   return(allClosed);
  }
  
//+------------------------------------------------------------------+
//| Close news-affected positions                                    |
//+------------------------------------------------------------------+
bool CloseNewsAffectedPositions()
  {
   ulong tickets[];

   int totalMatches = ArraySize(g_newsPositionMatches);
   int ticketCount = 0;

//--- Collect only positions marked for protection
   for(int i = 0; i < totalMatches; i++)
     {
      if(!g_newsPositionMatches[i].protectionRequired)
         continue;

      int newSize = ticketCount + 1;

      if(ArrayResize(tickets, newSize) != newSize)
        {
         Print("Prop Firm Guard: Could not expand affected-position ticket array.");

         return(false);
        }

      tickets[ticketCount] = g_newsPositionMatches[i].ticket;
      ticketCount++;
     }

   if(ticketCount == 0)
      return(true);

   bool allClosed = true;

   string reason =
      "News restriction: " +
      g_newsState.eventCurrency +
      " " +
      g_newsState.eventName;

//--- Close only the selected protection tickets
   for(int i = 0; i < ticketCount; i++)
     {
      if(!ClosePositionByTicket(tickets[i],
                                reason))
         allClosed = false;
     }

   return(allClosed);
  }
  
//+------------------------------------------------------------------+
//| Handle daily drawdown protection                                 |
//+------------------------------------------------------------------+
void HandleDailyDrawdownProtection()
  {
   if(!g_dailySession.balanceConfirmed)
      return;

   if(g_dailyDrawdown.status != COMPLIANCE_BREACHED)
     {
      g_dailyBreachWarned = false;

      return;
     }

   switch(InpDailyDrawdownAction)
     {
      case PROTECTION_WARN_ONLY:
         if(!g_dailyBreachWarned)
           {
            Alert("Prop Firm Guard: Daily drawdown limit breached.");
            Print("Prop Firm Guard: Daily drawdown breached. Action: WARN ONLY.");

            g_dailyBreachWarned = true;
           }

         break;

      case PROTECTION_CLOSE_AFFECTED:
      case PROTECTION_CLOSE_ALL:
         if(PositionsTotal() > 0)
           {
            if(!CloseAllPositions("Daily drawdown breach"))
               Print("Prop Firm Guard: One or more positions could not be closed after daily drawdown breach.");
           }

         break;
     }
  }

//+------------------------------------------------------------------+
//| Handle overall drawdown protection                               |
//+------------------------------------------------------------------+
void HandleOverallDrawdownProtection()
  {
   if(g_overallDrawdown.status != COMPLIANCE_BREACHED)
     {
      g_overallBreachWarned = false;

      return;
     }

   switch(InpOverallDrawdownAction)
     {
      case PROTECTION_WARN_ONLY:
         if(!g_overallBreachWarned)
           {
            Alert("Prop Firm Guard: Overall drawdown limit breached.");
            Print("Prop Firm Guard: Overall drawdown breached. Action: WARN ONLY.");

            g_overallBreachWarned = true;
           }

         break;

      case PROTECTION_CLOSE_AFFECTED:
      case PROTECTION_CLOSE_ALL:
         if(PositionsTotal() > 0)
           {
            if(!CloseAllPositions("Overall drawdown breach"))
               Print("Prop Firm Guard: One or more positions could not be closed after overall drawdown breach.");
           }

         break;
     }
  }

//+------------------------------------------------------------------+
//| Handle news protection                                           |
//+------------------------------------------------------------------+
void HandleNewsProtection()
  {
   if(g_newsState.holdingStatus != NEWS_HOLDING_PROTECTION ||
      !g_newsState.eventFound)
      return;

   switch(InpNewsRestrictionAction)
     {
      case PROTECTION_WARN_ONLY:
         if(g_lastNewsWarnedEventId != g_newsState.eventId)
           {
            Alert("Prop Firm Guard: News holding restriction active for ",
                  g_newsState.eventCurrency,
                  " ",
                  g_newsState.eventName,
                  ".");

            Print("Prop Firm Guard: News protection required. Action: WARN ONLY.");

            g_lastNewsWarnedEventId = g_newsState.eventId;
           }

         break;

      case PROTECTION_CLOSE_AFFECTED:
         if(g_newsState.protectionPositions > 0)
           {
            if(!CloseNewsAffectedPositions())
               Print("Prop Firm Guard: One or more news-affected positions could not be closed.");
           }

         break;

      case PROTECTION_CLOSE_ALL:
         if(PositionsTotal() > 0)
           {
            string reason =
               "News holding restriction: " +
               g_newsState.eventCurrency +
               " " +
               g_newsState.eventName;

            if(!CloseAllPositions(reason))
               Print("Prop Firm Guard: One or more positions could not be closed during news restriction.");
           }

         break;
     }
  }
  
//+------------------------------------------------------------------+
//| Manage protection actions                                        |
//+------------------------------------------------------------------+
void ManageProtectionActions()
  {
//--- Process account-wide financial protection first
   HandleDailyDrawdownProtection();
   HandleOverallDrawdownProtection();

//--- Apply news protection to any remaining exposure
   HandleNewsProtection();
  }
//+------------------------------------------------------------------+