//+------------------------------------------------------------------+
//|                                                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
  };

//+------------------------------------------------------------------+
//| 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
  };

//+------------------------------------------------------------------+
//| 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

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;             // Current-day session availability

//+------------------------------------------------------------------+
//| 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;
  }
  
//+------------------------------------------------------------------+
//| 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 monitoring interval
   if(InpTimerSeconds < 1)
     {
      Print("Prop Firm Guard: Timer interval must be at least 1 second.");

      return(INIT_PARAMETERS_INCORRECT);
     }

//--- Validate the configured prop-firm rules
   if(!ValidateComplianceInputs())
      return(INIT_PARAMETERS_INCORRECT);

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

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

      return(INIT_FAILED);
     }

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

      CloseDatabase();

      return(INIT_FAILED);
     }

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

      CloseDatabase();

      return(INIT_FAILED);
     }

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

      CloseDatabase();

      return(INIT_FAILED);
     }

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

//--- Create confirmation controls when required
   if(!CreateDailySessionControls())
     {
      Print("Prop Firm Guard: Could not create daily session controls.");

      DeleteDailySessionControls();
      CloseDatabase();

      return(INIT_FAILED);
     }

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

      DeleteDailySessionControls();
      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();
  }
  
//+------------------------------------------------------------------+
//| 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.");
     }
  }
//+------------------------------------------------------------------+