//+------------------------------------------------------------------+
//| CEconomicCalendar.mqh - MQL5 Economic Calendar Integration          |
//| Provides direct access to MQL5 Economic Calendar for real-time       |
//| news event detection and impact analysis                            |
//| Based on MQL5 article: "Using the MQL5 Economic Calendar for News   |
//| Filter (Part 3): Surviving Terminal Restarts During News Window"  |
//+------------------------------------------------------------------+
#ifndef CECONOMICCALENDAR_MQH
#define CECONOMICCALENDAR_MQH

#include "CErrorRecovery.mqh"
#include "CUnifiedFileIO.mqh"

// Event importance levels
enum ENUM_EVENT_IMPORTANCE
{
   EVENT_IMPORTANCE_LOW = 0,
   EVENT_IMPORTANCE_MEDIUM = 1,
   EVENT_IMPORTANCE_HIGH = 2
};

// Event type
enum ENUM_EVENT_TYPE
{
   EVENT_TYPE_NONE = 0,
   EVENT_TYPE_ECONOMIC = 1,
   EVENT_TYPE_POLITICAL = 2,
   EVENT_TYPE_NATURAL = 3,
   EVENT_TYPE_CENTRAL_BANK = 4
};

//+------------------------------------------------------------------+
//| Economic Event Structure                                           |
//+------------------------------------------------------------------+
struct SEconomicEvent
{
   long         id;
   string       name;
   string       currency;
   string       country;
   datetime     event_time;
   int          importance;        // 0=low, 1=medium, 2=high
   double       actual_value;
   double       forecast_value;
   double       previous_value;
   bool         has_actual;
   bool         has_forecast;
   bool         has_previous;
   string       event_type;
   
   SEconomicEvent()
   {
      id = 0;
      name = "";
      currency = "";
      country = "";
      event_time = 0;
      importance = 0;
      actual_value = 0.0;
      forecast_value = 0.0;
      previous_value = 0.0;
      has_actual = false;
      has_forecast = false;
      has_previous = false;
      event_type = "";
   }
};

//+------------------------------------------------------------------+
//| News Impact Analysis Result                                         |
//+------------------------------------------------------------------+
struct SNewsImpact
{
   bool         is_news_time;
   int          current_importance;
   int          upcoming_importance;
   datetime     next_event_time;
   string       next_event_name;
   double       volatility_prediction;
   double       confidence_adjustment;
   string       reason;
   
   SNewsImpact()
   {
      is_news_time = false;
      current_importance = 0;
      upcoming_importance = 0;
      next_event_time = 0;
      next_event_name = "";
      volatility_prediction = 0.0;
      confidence_adjustment = 1.0;
      reason = "";
   }
};

//+------------------------------------------------------------------+
//| Economic Calendar Manager                                           |
//+------------------------------------------------------------------+
class CEconomicCalendar
{
private:
   static CEconomicCalendar* s_instance;
   
   // Event cache
   SEconomicEvent       m_events[];
   int                  m_event_count;
   int                  m_max_events;
   datetime             m_last_update;
   int                  m_update_interval_sec;
   
   // Currency filter
   string               m_currencies[];
   int                  m_currency_count;
   
   // Configuration
   int                  m_lookback_hours;
   int                  m_lookahead_hours;
   bool                 m_use_api;
   bool                 m_use_fallback_file;
   string               m_fallback_filename;
   
   // Statistics
   int                  m_api_calls;
   int                  m_cache_hits;
   int                  m_cache_misses;
   
   // Error recovery
   CErrorRecovery*      m_error_recovery;
   CUnifiedFileIO*      m_file_io;
   
   // Market watch indices for fast lookup
   int                  m_currency_handles[];

public:
   CEconomicCalendar()
   {
      m_event_count = 0;
      m_max_events = 500;
      ArrayResize(m_events, m_max_events);
      
      m_last_update = 0;
      m_update_interval_sec = 300; // 5 minutes
      
      m_currency_count = 0;
      ArrayResize(m_currencies, 10);
      
      m_lookback_hours = 2;
      m_lookahead_hours = 24;
      m_use_api = true;
      m_use_fallback_file = true;
      m_fallback_filename = "DualEA\\economic_calendar.json";
      
      m_api_calls = 0;
      m_cache_hits = 0;
      m_cache_misses = 0;
      
      m_error_recovery = CErrorRecovery::Instance();
      m_file_io = CUnifiedFileIO::Instance();
   }
   
   ~CEconomicCalendar()
   {
   }
   
   static CEconomicCalendar* Instance()
   {
      if(s_instance == NULL)
         s_instance = new CEconomicCalendar();
      return s_instance;
   }
   
   static void Destroy()
   {
      if(s_instance != NULL)
      {
         delete s_instance;
         s_instance = NULL;
      }
   }
   
   //+------------------------------------------------------------------+
   //| Configuration                                                      |
   //+------------------------------------------------------------------+
   void SetCurrencies(const string &currencies[])
   {
      int count = ArraySize(currencies);
      ArrayResize(m_currencies, count);
      for(int i = 0; i < count; i++)
      {
         m_currencies[i] = currencies[i];
      }
      m_currency_count = count;
   }
   
   void SetUpdateInterval(int seconds) { m_update_interval_sec = seconds; }
   void SetLookbackHours(int hours) { m_lookback_hours = hours; }
   void SetLookaheadHours(int hours) { m_lookahead_hours = hours; }
   void SetUseAPI(bool use) { m_use_api = use; }
   void SetFallbackFile(const string filename) { m_fallback_filename = filename; }
   
   //+------------------------------------------------------------------+
   //| Update event cache from MQL5 Calendar                              |
   //+------------------------------------------------------------------+
   bool UpdateEvents()
   {
      datetime now = TimeCurrent();
      
      // Check if update needed
      if(m_last_update > 0 && (now - m_last_update) < m_update_interval_sec)
      {
         m_cache_hits++;
         return true;
      }
      
      m_cache_misses++;
      
      // Clear existing events
      m_event_count = 0;
      ArrayResize(m_events, m_max_events);
      
      bool success = false;
      
      if(m_use_api)
      {
         success = FetchFromAPI();
      }
      
      if(!success && m_use_fallback_file)
      {
         success = FetchFromFallbackFile();
      }
      
      if(success)
      {
         m_last_update = now;
         SortEventsByTime();
         Log("Updated economic calendar: " + IntegerToString(m_event_count) + " events");
      }
      
      return success;
   }
   
   //+------------------------------------------------------------------+
   //| Fetch events from MQL5 Calendar API                                |
   //+------------------------------------------------------------------+
   bool FetchFromAPI()
   {
      // Calculate date range
      datetime from_date = TimeCurrent() - (m_lookback_hours * 3600);
      datetime to_date = TimeCurrent() + (m_lookahead_hours * 3600);
      
      MqlCalendarValue values[];
      
      // Try to get calendar values
      // If specific currencies are set, filter by them
      int retrieved = 0;
      
      if(m_currency_count > 0)
      {
         // Fetch for specific currencies
         for(int c = 0; c < m_currency_count && m_event_count < m_max_events; c++)
         {
            string currency = m_currencies[c];
            
            // Reset array
            ArrayResize(values, 0);
            
            // Get calendar values
            int count = CalendarValueHistory(values, from_date, to_date, currency);
            
            if(count > 0)
            {
               for(int i = 0; i < count && m_event_count < m_max_events; i++)
               {
                  if(AddCalendarValue(values[i]))
                     retrieved++;
               }
            }
            
            m_api_calls++;
         }
      }
      else
      {
         // Get all calendar values
         int count = CalendarValueHistory(values, from_date, to_date, NULL);
         
         if(count > 0)
         {
            for(int i = 0; i < count && m_event_count < m_max_events; i++))
            {
               if(AddCalendarValue(values[i]))
                  retrieved++;
            }
         }
         
         m_api_calls++;
      }
      
      return (retrieved > 0);
   }
   
   //+------------------------------------------------------------------+
   //| Add calendar value to cache                                        |
   //+------------------------------------------------------------------+
   bool AddCalendarValue(const MqlCalendarValue &value)
   {
      if(m_event_count >= m_max_events)
         return false;
      
      SEconomicEvent event;
      
      // Get event details
      MqlCalendarEvent event_info;
      if(!CalendarEventById(value.event_id, event_info))
         return false;
      
      // Get country info
      MqlCalendarCountry country_info;
      if(!CalendarCountryById(event_info.country_id, country_info))
         return false;
      
      event.id = value.event_id;
      event.name = event_info.name;
      event.currency = country_info.currency;
      event.country = country_info.code;
      event.event_time = value.time;
      
      // Determine importance
      switch(event_info.importance)
      {
         case CALENDAR_IMPORTANCE_LOW:
            event.importance = EVENT_IMPORTANCE_LOW;
            break;
         case CALENDAR_IMPORTANCE_MODERATE:
            event.importance = EVENT_IMPORTANCE_MEDIUM;
            break;
         case CALENDAR_IMPORTANCE_HIGH:
            event.importance = EVENT_IMPORTANCE_HIGH;
            break;
      }
      
      // Values
      if(value.actual_type != CALENDAR_VALUE_TYPE_NA)
      {
         event.actual_value = value.actual_value;
         event.has_actual = true;
      }
      
      if(value.forecast_type != CALENDAR_VALUE_TYPE_NA)
      {
         event.forecast_value = value.forecast_value;
         event.has_forecast = true;
      }
      
      if(value.prev_value != 0)
      {
         event.previous_value = value.prev_value;
         event.has_previous = true;
      }
      
      // Event type
      switch(event_info.type)
      {
         case CALENDAR_TYPE_EVENT:
            event.event_type = "economic";
            break;
         case CALENDAR_TYPE_INDICATOR:
            event.event_type = "indicator";
            break;
         case CALENDAR_TYPE_HOLIDAY:
            event.event_type = "holiday";
            break;
         default:
            event.event_type = "other";
      }
      
      // Check for duplicates
      for(int i = 0; i < m_event_count; i++)
      {
         if(m_events[i].id == event.id && m_events[i].event_time == event.event_time)
            return false; // Duplicate
      }
      
      m_events[m_event_count] = event;
      m_event_count++;
      
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| Fetch from fallback file                                           |
   //+------------------------------------------------------------------+
   bool FetchFromFallbackFile()
   {
      string content;
      if(!m_file_io.ReadFile(m_fallback_filename, content, true))
         return false;
      
      // Parse JSON (simplified - would need full JSON parser for production)
      // For now, just log that we loaded the file
      Log("Loaded fallback calendar file: " + m_fallback_filename);
      
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| Sort events by time                                                |
   //+------------------------------------------------------------------+
   void SortEventsByTime()
   {
      // Simple bubble sort for small arrays
      for(int i = 0; i < m_event_count - 1; i++)
      {
         for(int j = 0; j < m_event_count - i - 1; j++)
         {
            if(m_events[j].event_time > m_events[j + 1].event_time)
            {
               SEconomicEvent temp = m_events[j];
               m_events[j] = m_events[j + 1];
               m_events[j + 1] = temp;
            }
         }
      }
   }
   
   //+------------------------------------------------------------------+
   //| Check if news time (main entry point for trading decisions)       |
   //+------------------------------------------------------------------+
   SNewsImpact CheckNewsImpact(const string symbol, int buffer_minutes_before = 30, int buffer_minutes_after = 30)
   {
      SNewsImpact impact;
      
      // Ensure events are current
      UpdateEvents();
      
      datetime now = TimeCurrent();
      
      // Extract currency from symbol
      string base_currency = StringSubstr(symbol, 0, 3);
      string quote_currency = StringSubstr(symbol, 3, 3);
      
      // Check for active news events
      for(int i = 0; i < m_event_count; i++)
      {
         SEconomicEvent &event = m_events[i];
         
         // Skip if not relevant to this symbol
         if(!IsEventRelevant(event, base_currency, quote_currency))
            continue;
         
         // Calculate effective window
         datetime window_start = event.event_time - (buffer_minutes_before * 60);
         datetime window_end = event.event_time + (buffer_minutes_after * 60);
         
         // Check if currently in news window
         if(now >= window_start && now <= window_end)
         {
            impact.is_news_time = true;
            impact.current_importance = MathMax(impact.current_importance, event.importance);
            
            if(impact.reason != "") impact.reason += "; ";
            impact.reason += event.name + " (" + IntegerToString(event.importance) + ")";
         }
         
         // Check for upcoming events
         if(event.event_time > now && event.event_time < impact.next_event_time)
         {
            impact.next_event_time = event.event_time;
            impact.next_event_name = event.name;
            impact.upcoming_importance = event.importance;
         }
      }
      
      // Calculate confidence adjustment
      impact.confidence_adjustment = CalculateConfidenceAdjustment(impact);
      impact.volatility_prediction = PredictVolatility(impact);
      
      return impact;
   }
   
   //+------------------------------------------------------------------+
   //| Check if event is relevant to symbol                               |
   //+------------------------------------------------------------------+
   bool IsEventRelevant(const SEconomicEvent &event, const string base_currency, const string quote_currency)
   {
      // Direct currency match
      if(event.currency == base_currency || event.currency == quote_currency)
         return true;
      
      // Major USD events affect all pairs
      if(event.currency == "USD" && (base_currency == "USD" || quote_currency == "USD"))
         return true;
      
      // Global events (no specific currency)
      if(event.currency == "" && event.importance >= EVENT_IMPORTANCE_HIGH)
         return true;
      
      return false;
   }
   
   //+------------------------------------------------------------------+
   //| Calculate confidence adjustment based on news                      |
   //+------------------------------------------------------------------+
   double CalculateConfidenceAdjustment(const SNewsImpact &impact)
   {
      if(!impact.is_news_time)
         return 1.0;
      
      // Reduce confidence during news
      double adjustment = 1.0;
      
      switch(impact.current_importance)
      {
         case EVENT_IMPORTANCE_LOW:
            adjustment = 0.9; // 10% reduction
            break;
         case EVENT_IMPORTANCE_MEDIUM:
            adjustment = 0.75; // 25% reduction
            break;
         case EVENT_IMPORTANCE_HIGH:
            adjustment = 0.5; // 50% reduction
            break;
      }
      
      return adjustment;
   }
   
   //+------------------------------------------------------------------+
   //| Predict volatility based on news                                   |
   //+------------------------------------------------------------------+
   double PredictVolatility(const SNewsImpact &impact)
   {
      if(!impact.is_news_time)
         return 0.0;
      
      // Base prediction on importance
      double base_volatility = 0.0;
      
      switch(impact.current_importance)
      {
         case EVENT_IMPORTANCE_LOW:
            base_volatility = 0.2;
            break;
         case EVENT_IMPORTANCE_MEDIUM:
            base_volatility = 0.5;
            break;
         case EVENT_IMPORTANCE_HIGH:
            base_volatility = 1.0;
            break;
      }
      
      // Could be enhanced with historical volatility data
      return base_volatility;
   }
   
   //+------------------------------------------------------------------+
   //| Get next significant event                                         |
   //+------------------------------------------------------------------+
   SEconomicEvent GetNextEvent(int min_importance = EVENT_IMPORTANCE_MEDIUM)
   {
      SEconomicEvent next;
      
      UpdateEvents();
      
      datetime now = TimeCurrent();
      
      for(int i = 0; i < m_event_count; i++)
      {
         if(m_events[i].event_time > now && m_events[i].importance >= min_importance)
         {
            next = m_events[i];
            break;
         }
      }
      
      return next;
   }
   
   //+------------------------------------------------------------------+
   //| Export events to file (for ML training)                           |
   //+------------------------------------------------------------------+
   bool ExportEventsToFile(const string filename)
   {
      string content = "timestamp,event_name,currency,importance,actual,forecast,previous,type\n";
      
      for(int i = 0; i < m_event_count; i++)
      {
         SEconomicEvent &e = m_events[i];
         content += StringFormat("%s,%s,%s,%d,%.5f,%.5f,%.5f,%s\n",
            TimeToString(e.event_time, TIME_DATE|TIME_SECONDS),
            e.name,
            e.currency,
            e.importance,
            e.actual_value,
            e.forecast_value,
            e.previous_value,
            e.event_type
         );
      }
      
      return m_file_io.WriteFile(filename, content, true, false);
   }
   
   //+------------------------------------------------------------------+
   //| Statistics                                                         |
   //+------------------------------------------------------------------+
   string GetStatistics()
   {
      string stats = StringFormat(
         "=== Economic Calendar Statistics ===\n" +
         "Events cached: %d\n" +
         "API calls: %d\n" +
         "Cache hits: %d\n" +
         "Cache misses: %d\n" +
         "Last update: %s",
         m_event_count,
         m_api_calls,
         m_cache_hits,
         m_cache_misses,
         (m_last_update > 0 ? TimeToString(m_last_update) : "Never")
      );
      
      return stats;
   }
   
   //+------------------------------------------------------------------+
   //| Utility functions                                                  |
   //+------------------------------------------------------------------+
   void Log(const string message)
   {
      Print("[EconomicCalendar] " + message);
   }
   
   int GetEventCount() const { return m_event_count; }
   bool IsCacheValid() const { return (TimeCurrent() - m_last_update) < m_update_interval_sec; }
   datetime GetLastUpdate() const { return m_last_update; }
};

// Static instance initialization
CEconomicCalendar* CEconomicCalendar::s_instance = NULL;

// Convenience macros
#define CHECK_NEWS_IMPACT(symbol, buffer_before, buffer_after) \
   CEconomicCalendar::Instance().CheckNewsImpact(symbol, buffer_before, buffer_after)

#define GET_NEXT_EVENT(min_importance) \
   CEconomicCalendar::Instance().GetNextEvent(min_importance)

#define UPDATE_CALENDAR() \
   CEconomicCalendar::Instance().UpdateEvents()

#endif // CECONOMICCALENDAR_MQH