//+------------------------------------------------------------------+
//|                                           SessionManager.mqh     |
//|                      Session Volume Profile Engine               |
//+------------------------------------------------------------------+
#ifndef SESSION_MANAGER_MQH
#define SESSION_MANAGER_MQH

//--- Session type enumeration
enum ENUM_SESSION_TYPE
  {
   SESSION_LONDON    = 0, // London 08:00 - 17:00 UTC
   SESSION_NEW_YORK  = 1, // New York 13:00 - 22:00 UTC
   SESSION_CUSTOM    = 2  // User-defined hours
  };

//+------------------------------------------------------------------+
//| Session Manager Class                                            |
//+------------------------------------------------------------------+
class CSessionManager
  {
private:
   ENUM_SESSION_TYPE  m_session_type;
   int                m_start_hour;
   int                m_start_minute;
   int                m_end_hour;
   int                m_end_minute;
   datetime           m_session_start;
   datetime           m_session_end;
   datetime           m_last_session_date;

public:
                     CSessionManager(void);
                    ~CSessionManager(void);
   void               Configure(ENUM_SESSION_TYPE type,
                                int start_hour, int start_minute,
                                int end_hour, int end_minute);
   bool               Update(datetime current_time);
   bool               IsNewSession(void) const;
   datetime           GetSessionStart(void) const;
   datetime           GetSessionEnd(void)   const;

private:
   void               ResolveSessionHours(void);
  };

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSessionManager::CSessionManager(void)
   : m_session_type(SESSION_LONDON),
     m_start_hour(8),
     m_start_minute(0),
     m_end_hour(17),
     m_end_minute(0),
     m_session_start(0),
     m_session_end(0),
     m_last_session_date(0)
  {
  }

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSessionManager::~CSessionManager(void)
  {
  }

//+------------------------------------------------------------------+
//| Configure session parameters                                     |
//+------------------------------------------------------------------+
void CSessionManager::Configure(ENUM_SESSION_TYPE type,
                                int start_hour, int start_minute,
                                int end_hour, int end_minute)
  {
   m_session_type   = type;
   m_start_hour     = start_hour;
   m_start_minute   = start_minute;
   m_end_hour       = end_hour;
   m_end_minute     = end_minute;
   ResolveSessionHours();
  }

//+------------------------------------------------------------------+
//| Resolve hard-coded session hours for built-in types              |
//+------------------------------------------------------------------+
void CSessionManager::ResolveSessionHours(void)
  {
   if(m_session_type == SESSION_LONDON)
     {
      m_start_hour   = 8;
      m_start_minute = 0;
      m_end_hour     = 17;
      m_end_minute   = 0;
     }
   else
      if(m_session_type == SESSION_NEW_YORK)
        {
         m_start_hour   = 13;
         m_start_minute = 0;
         m_end_hour     = 22;
         m_end_minute   = 0;
        }
//--- SESSION_CUSTOM retains caller-supplied values
  }

//+------------------------------------------------------------------+
//| Update session boundaries and detect rollover                    |
//+------------------------------------------------------------------+
bool CSessionManager::Update(datetime current_time)
  {
//--- Extract the calendar date component from current_time
   MqlDateTime dt;
   TimeToStruct(current_time, dt);

//--- Build session start and end for today
   dt.hour   = m_start_hour;
   dt.min    = m_start_minute;
   dt.sec    = 0;
   datetime today_start = StructToTime(dt);

   dt.hour   = m_end_hour;
   dt.min    = m_end_minute;
   dt.sec    = 0;
   datetime today_end = StructToTime(dt);

//--- Detect new session by comparing today's date to the last recorded date
   bool is_new = (today_start != m_last_session_date);

   if(is_new)
     {
      m_session_start      = today_start;
      m_session_end        = today_end;
      m_last_session_date  = today_start;
     }

   return(is_new);
  }

//+------------------------------------------------------------------+
//| Return true when current Update call detected a new session      |
//+------------------------------------------------------------------+
bool CSessionManager::IsNewSession(void) const
  {
   return(m_last_session_date == m_session_start);
  }

//+------------------------------------------------------------------+
//| Return session start timestamp                                   |
//+------------------------------------------------------------------+
datetime CSessionManager::GetSessionStart(void) const
  {
   return(m_session_start);
  }

//+------------------------------------------------------------------+
//| Return session end timestamp                                     |
//+------------------------------------------------------------------+
datetime CSessionManager::GetSessionEnd(void) const
  {
   return(m_session_end);
  }

#endif // SESSION_MANAGER_MQH
//+------------------------------------------------------------------+