#ifndef TRADING_SYSTEM_H
#define TRADING_SYSTEM_H

#include <QObject>
#include <QTimer>
#include <QMutex>
#include <QMap>
#include <QList>
#include "../common_structures/TradingStructures.h"

// Forward declarations
class DataBuffer;
class DataQualityValidator;
class OrderProcessor;
class BigOrderManager;
class OrderBookParser;
class FaultToleranceManager;
class SubscriptionManager;
class ConfigurationManager;
class LogManager;
class EventBus;

class TradingSystem : public QObject
{
    Q_OBJECT
public:
    static TradingSystem* instance();
    
    // System lifecycle
    bool initialize(const Trading::SystemConfig& config = Trading::SystemConfig());
    void shutdown();
    bool isInitialized() const { return m_initialized; }
    
    // Component access
    DataBuffer* dataBuffer() const;
    DataQualityValidator* dataQuality() const;
    OrderProcessor* orderProcessor() const;
    BigOrderManager* bigOrderManager() const;
    OrderBookParser* orderBookParser() const;
    FaultToleranceManager* faultTolerance() const;
    SubscriptionManager* subscriptionManager() const;
    ConfigurationManager* configManager() const;
    LogManager* logManager() const;
    EventBus* eventBus() const;
    
    // System control
    void start();
    void stop();
    void pause();
    void resume();
    bool isRunning() const { return m_running; }
    bool isPaused() const { return m_paused; }
    
    // Status and monitoring
    Trading::SystemConfig getSystemConfig() const;
    Trading::PerformanceMetrics getPerformanceMetrics() const;
    QString getSystemStatus() const;
    QMap<QString, QVariant> getSystemStats() const;
    
    // Data flow control
    void setDataFlowEnabled(bool enabled);
    bool isDataFlowEnabled() const { return m_dataFlowEnabled; }
    
    // Error handling
    QString getLastError() const;
    void clearErrors();

signals:
    void systemInitialized();
    void systemStarted();
    void systemStopped();
    void systemPaused();
    void systemResumed();
    void systemError(const QString& error);
    void systemStatusChanged(const QString& status);
    void performanceMetricsUpdated(const Trading::PerformanceMetrics& metrics);

private:
    explicit TradingSystem(QObject *parent = nullptr);
    ~TradingSystem();
    
    void initializeComponents();
    void shutdownComponents();
    void updatePerformanceMetrics();
    void handleComponentError(const QString& component, const QString& error);
    void validateSystemState();
    
    // System state
    bool m_initialized = false;
    bool m_running = false;
    bool m_paused = false;
    bool m_dataFlowEnabled = true;
    
    // System configuration
    Trading::SystemConfig m_systemConfig;
    Trading::PerformanceMetrics m_performanceMetrics;
    
    // Component instances
    DataBuffer* m_dataBuffer = nullptr;
    DataQualityValidator* m_dataQuality = nullptr;
    OrderProcessor* m_orderProcessor = nullptr;
    BigOrderManager* m_bigOrderManager = nullptr;
    OrderBookParser* m_orderBookParser = nullptr;
    FaultToleranceManager* m_faultTolerance = nullptr;
    SubscriptionManager* m_subscriptionManager = nullptr;
    ConfigurationManager* m_configManager = nullptr;
    LogManager* m_logManager = nullptr;
    EventBus* m_eventBus = nullptr;
    
    // Monitoring and control
    QTimer* m_monitoringTimer;
    QTimer* m_metricsUpdateTimer;
    QStringList m_errorLog;
    
    // Synchronization
    mutable QMutex m_mutex;
};

#endif // TRADING_SYSTEM_H