#pragma once
#include "../Common/AdaptiveTypes.h"
#include <queue>

#include "NVDECAV1Decoder.h"

namespace VavCore {

// Enhanced NVDEC decoder with adaptive quality adjustment
class AdaptiveNVDECDecoder : public NVDECAV1Decoder {
public:
    AdaptiveNVDECDecoder();
    ~AdaptiveNVDECDecoder() override;

    // Enhanced initialization with adaptive features
    bool Initialize(const VideoMetadata& metadata) override;
    bool Initialize(const VideoMetadata& metadata, const AdaptiveConfig& config);

    // Override decode with adaptive logic
    bool DecodeFrame(const uint8_t* packet_data, size_t packet_size, VideoFrame& output_frame) override;

    // Adaptive quality control
    void SetQualityLevel(QualityLevel level);
    QualityLevel GetCurrentQualityLevel() const { return m_currentQuality; }

    // Performance monitoring
    PerformanceMetrics GetPerformanceMetrics() const;
    void UpdatePerformanceMetrics(double decode_time, double render_time);

    // Manual override controls
    void EnableAdaptiveMode(bool enable) { m_adaptiveEnabled = enable; }
    void SetTargetFrameRate(double fps);
    void ForceQualityAdjustment(); // Immediate adjustment trigger

    // Configuration management
    void UpdateConfig(const AdaptiveConfig& config) { m_config = config; }
    AdaptiveConfig GetConfig() const { return m_config; }

private:
    // Adaptive control state
    QualityLevel m_currentQuality = QualityLevel::ULTRA;
    QualityLevel m_targetQuality = QualityLevel::ULTRA;
    AdaptiveConfig m_config;

    // Performance monitoring
    mutable std::mutex m_metricsMutex;
    PerformanceMetrics m_metrics;
    std::queue<double> m_recentDecodeTimes;
    std::queue<double> m_recentRenderTimes;

    // Adaptive decision making
    std::atomic<bool> m_adaptiveEnabled{true};
    uint32_t m_stableFrameCount = 0;
    bool m_needsReconfiguration = false;

    // Original video properties for scaling calculations
    uint32_t m_originalWidth = 0;
    uint32_t m_originalHeight = 0;

    // Current scaled properties
    uint32_t m_currentScaledWidth = 0;
    uint32_t m_currentScaledHeight = 0;

    // Adaptive logic methods
    void AnalyzePerformanceAndAdjust();
    bool ShouldAdjustQuality(double avgDecodeTime, double avgRenderTime);
    QualityLevel DetermineOptimalQuality(double totalFrameTime);

    // NVDEC reconfiguration methods
    bool ReconfigureDecoder(uint32_t newWidth, uint32_t newHeight);
    bool UpdateDecodeSurfaces(uint32_t newCount);
    void CalculateScaledDimensions(QualityLevel quality, uint32_t& width, uint32_t& height);

    // Performance calculation helpers
    void UpdateMovingAverage(std::queue<double>& queue, double newValue, size_t maxSize = 30);
    double CalculateMovingAverage(const std::queue<double>& queue) const;

    // Quality level utilities
    static double GetQualityScaleFactor(QualityLevel level);
    static std::string QualityLevelToString(QualityLevel level);
};

// Utility functions for adaptive decoding
namespace AdaptiveUtils {
    // Performance estimation
    double EstimateOptimalFrameRate(const PerformanceMetrics& metrics);
    QualityLevel RecommendQualityForTargetFPS(double targetFPS, double currentFPS);

    // System resource monitoring
    double GetCurrentCPUUsage();
    double GetCurrentGPUUsage();
    size_t GetAvailableGPUMemory();

    // Configuration presets
    AdaptiveConfig CreateConfigForTarget(double targetFPS);
    AdaptiveConfig GetConservativeConfig();   // Aggressive quality reduction
    AdaptiveConfig GetBalancedConfig();       // Balanced performance/quality
    AdaptiveConfig GetQualityConfig();        // Prioritize quality over performance
}

} // namespace VavCore