#ifndef DATA_QUALITY_VALIDATOR_H
#define DATA_QUALITY_VALIDATOR_H

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

// Data quality metrics
struct DataQualityMetrics {
    qint64 totalPackets = 0;
    qint64 validPackets = 0;
    qint64 invalidPackets = 0;
    qint64 suspiciousPackets = 0;
    double validityRate = 0.0;
    QDateTime lastUpdate;
    
    void updateMetrics(bool isValid, bool isSuspicious = false) {
        totalPackets++;
        if (isValid) {
            validPackets++;
        } else {
            invalidPackets++;
        }
        if (isSuspicious) {
            suspiciousPackets++;
        }
        validityRate = totalPackets > 0 ? static_cast<double>(validPackets) / totalPackets : 0.0;
        lastUpdate = QDateTime::currentDateTime();
    }
};

// Data validation rules
struct ValidationRules {
    double maxPriceDeviation = 0.1; // 10%
    double minValidPrice = 0.01;
    double maxValidPrice = 1000000.0;
    qint64 minValidVolume = 1;
    qint64 maxValidVolume = 1000000000;
    int maxOrderBookDepth = 10;
    int maxTimestampDeviationMs = 5000; // 5 seconds
    bool enableCrossMarketValidation = true;
    bool enableStatisticalOutlierDetection = true;
    
    bool isValid() const {
        return maxPriceDeviation > 0 && minValidPrice > 0 && maxValidPrice > minValidPrice;
    }
};

class DataQualityValidator : public QObject
{
    Q_OBJECT
public:
    static DataQualityValidator* instance();
    
    // Configuration
    void setValidationRules(const ValidationRules& rules);
    ValidationRules getValidationRules() const;
    
    // Data validation
    bool validateQuoteData(const Trading::QuoteData& quote);
    bool validateOrderBook(const Trading::OrderBook& orderBook);
    bool validateOrder(const Trading::Order& order);
    bool validateTrade(const Trading::Trade& trade);
    bool validateDataPacket(const Trading::DataPacket& packet);
    
    // Quality monitoring
    DataQualityMetrics getQualityMetrics() const;
    void resetMetrics();
    
    // Anomaly detection
    void addAnomalyPattern(const QString& patternName, const QVariant& pattern);
    void removeAnomalyPattern(const QString& patternName);
    bool checkForAnomalies(const Trading::DataPacket& packet);
    
    // Statistical validation
    void updatePriceStatistics(const QString& symbol, double price);
    void updateVolumeStatistics(const QString& symbol, qint64 volume);
    bool isStatisticalOutlier(const QString& symbol, double value, const QString& metric) const;

signals:
    void dataValidationFailed(const Trading::DataPacket& packet, const QString& reason);
    void dataQualityAlert(const QString& symbol, const QString& alertType, const QString& message);
    void qualityMetricsUpdated(const DataQualityMetrics& metrics);
    void anomalyDetected(const Trading::DataPacket& packet, const QString& pattern);

private:
    explicit DataQualityValidator(QObject *parent = nullptr);
    ~DataQualityValidator();
    
    bool validateQuoteInternal(const Trading::QuoteData& quote);
    bool validateOrderBookInternal(const Trading::OrderBook& orderBook);
    bool validateOrderInternal(const Trading::Order& order);
    bool validateTradeInternal(const Trading::Trade& trade);
    void updateQualityMetrics(bool isValid, bool isSuspicious = false);
    void checkCrossMarketData(const Trading::DataPacket& packet);
    void performStatisticalAnalysis(const Trading::DataPacket& packet);
    
    // Validation rules
    ValidationRules m_validationRules;
    
    // Quality metrics
    DataQualityMetrics m_qualityMetrics;
    
    // Statistical data
    QMap<QString, QList<double>> m_priceHistory;
    QMap<QString, QList<qint64>> m_volumeHistory;
    QMap<QString, QMap<QString, double>> m_statisticalModels;
    
    // Anomaly patterns
    QMap<QString, QVariant> m_anomalyPatterns;
    
    // Monitoring timers
    QTimer* m_metricsUpdateTimer;
    QTimer* m_statisticalUpdateTimer;
    
    // Synchronization
    mutable QMutex m_mutex;
};

#endif // DATA_QUALITY_VALIDATOR_H