// IVideoEncoder.h
#pragma once
#include <memory>
#include <vector>

struct EncoderConfig {
    int width = 1920;
    int height = 1080;
    int maxFps = 30;
    int targetBitrateKbps = 3000; // 目标码率
    int maxBitrateKbps = 4000;    // 最大码率 (Capped VBR)
    bool enableHwAccel = true;
    // NVUSE 专用扩展字段
    struct NvuseExt {
        int presetGUID = 0;           // NV_ENC_PRESET_XXX
        int tuningInfo = 0;           // NV_ENC_TUNING_INFO_XXX
        int rcMode = 0;               // NV_ENC_PARAMS_RC_XXX (CBR/VBR/CBR_LOWDELAY_HQ)
        int gopLength = 30;
        bool enableIntraRefresh = true;
        int intraRefreshPeriod = 30;  // 循环内刷周期
        int qpMin = 18, qpMax = 40;
    } nvuse;
};

struct EncodedFrame {
    std::vector<uint8_t> data;
    int64_t timestampUs = 0;
    bool isKeyFrame = false;
    int width = 0, height = 0;
};

class IVideoEncoder {
public:
    virtual ~IVideoEncoder() = default;
    // 初始化编码器
    virtual bool Initialize(const EncoderConfig& config) = 0;
    // 编码一帧 (NV12/I420 -> H.264/HEVC AnnexB)
    virtual bool EncodeFrame(const uint8_t* yuvData, int strideY, int strideUV, 
                             int64_t timestampUs, bool forceKeyFrame, EncodedFrame& outFrame) = 0;
    // 运行时动态重配置 (核心：分辨率/码率/参数热切换)
    virtual bool Reconfigure(const EncoderConfig& newConfig) = 0;
    virtual void Release() = 0;
};

// NvuseEncoderAdapter.cpp
#include "IVideoEncoder.h"
#include <nvEncodeAPI.h>
// ... 省略 NVENC 指针获取、CUDA Context 创建等样板代码 ...

class NvuseEncoderAdapter : public IVideoEncoder {
    NVENC_API_FUNCTION_LIST nvenc_ = { NV_ENCODE_API_FUNCTION_LIST_VER };
    void* encoder_ = nullptr; // NVENC Encoder Handle
    CUcontext cu_context_ = nullptr;
    EncoderConfig current_config_;

    // 内部辅助：将业务配置映射为 NVENC 初始化参数
    NV_ENC_INITIALIZE_PARAMS BuildInitParams(const EncoderConfig& cfg) {
        NV_ENC_INITIALIZE_PARAMS initParams = { NV_ENC_INITIALIZE_PARAMS_VER };
        NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER };
        initParams.encodeConfig = &encodeConfig;
        initParams.encodeGUID = NV_ENC_CODEC_H264_GUID; // 或 HEVC
        initParams.presetGUID = static_cast<GUID>(cfg.nvuse.presetGUID); // 如 NV_ENC_PRESET_LOW_LATENCY_HP_GUID
        initParams.tuningInfo = static_cast<GUID>(cfg.nvuse.tuningInfo);   // 如 NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY

        // 关键：率控配置映射
        auto& rc = encodeConfig.rcParams;
        rc.rateControlMode = static_cast<NV_ENC_PARAMS_RC_MODE>(cfg.nvuse.rcMode); // NV_ENC_PARAMS_RC_VBR / _CBR_LOWDELAY_HQ
        rc.averageBitRate = cfg.targetBitrateKbps * 1000;
        rc.maxBitRate = cfg.maxBitrateKbps * 1000;
        rc.vbvBufferSize = cfg.targetBitrateKbps * 1000; // 1秒缓冲
        rc.vbvInitialDelay = rc.vbvBufferSize * 9 / 10;
        rc.enableMinQP = 1; rc.enableMaxQP = 1;
        rc.minQP.qpInterP = rc.minQP.qpIntra = cfg.nvuse.qpMin;
        rc.maxQP.qpInterP = rc.maxQP.qpIntra = cfg.nvuse.qpMax;

        // GOP 与 Intra Refresh (实现无 IDR 切分辨率的关键)
        encodeConfig.gopLength = cfg.nvuse.gopLength;
        encodeConfig.frameIntervalP = 1; // 连续 P 帧
        if (cfg.nvuse.enableIntraRefresh) {
            encodeConfig.intraRefreshEnable = 1;
            encodeConfig.intraRefreshPeriod = cfg.nvuse.intraRefreshPeriod;
            encodeConfig.intraRefreshCnt = 1; // 每帧刷新 1 个 MB 行/列
        }

        initParams.encodeWidth = cfg.width;
        initParams.encodeHeight = cfg.height;
        initParams.darWidth = cfg.width;
        initParams.darHeight = cfg.height;
        initParams.frameRateNum = cfg.maxFps;
        initParams.frameRateDen = 1;
        initParams.enableEncodeAsync = 1; // 异步编码流水线
        initParams.enablePTD = 1;         // 图片类型决策 (配合 WebRTC 外部控制)

        return initParams;
    }

public:
    bool Initialize(const EncoderConfig& config) override {
        // 1. 加载 nvEncodeAPI.dll / so, 填充 nvenc_ 函数表
        // 2. cuInit, cuDeviceGet, cuCtxCreate (或导入 WebRTC 传入的 CUcontext)
        // 3. nvenc_.nvEncOpenEncodeSessionEx(&openParams, &encoder_)
        // 4. nvenc_.nvEncInitializeEncoder(encoder_, &BuildInitParams(config))
        // 5. 分配输入输出 Buffer Pool (NV_ENC_CREATE_INPUT_BUFFER / BITSTREAM_BUFFER)
        current_config_ = config;
        return true; // 简化错误处理
    }

    bool EncodeFrame(...) override {
        // 1. nvEncMapInputResource / Copy YUV to Mapped Buffer
        // 2. 构造 NV_ENC_PIC_PARAMS picParams = { NV_ENC_PIC_PARAMS_VER };
        //    picParams.pictureStruct = NV_ENC_PIC_STRUCT_FRAME;
        //    picParams.forceIDR = forceKeyFrame; // WebRTC 请求关键帧时置位
        //    picParams.encodePicFlags = NV_ENC_PIC_FLAG_OUTPUT_AS_BITSTREAM;
        // 3. nvEncEncodePicture(encoder_, &picParams)
        // 4. 异步查询完成事件 -> nvEncLockBitstream -> 拷贝数据到 EncodedFrame -> nvEncUnlockBitstream
        return true;
    }

    // 核心实现：动态重配置
    bool Reconfigure(const EncoderConfig& newConfig) override {
        if (!encoder_) return false;

        // 1. 判断是否需要完全重建 Session (编码器/预设/Profile 变更通常需重建)
        bool needReinit = (current_config_.nvuse.presetGUID != newConfig.nvuse.presetGUID) ||
                          (current_config_.nvuse.rcMode != newConfig.nvuse.rcMode) ||
                          (current_config_.width != newConfig.width && 
                           (newConfig.width > current_config_.width || newConfig.height > current_config_.height)); // 超过初始化最大分辨率需重建

        if (needReinit) {
            // 降级策略：销毁重建 (实际工程中需处理帧丢失、同步信令)
            Release();
            return Initialize(newConfig);
        }

        // 2. 热更新参数 (NvEncReconfigureEncoder)
        NV_ENC_RECONFIGURE_PARAMS reconfigParams = { NV_ENC_RECONFIGURE_PARAMS_VER };
        NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER };
        reconfigParams.reInitEncodeParams = &encodeConfig;
        
        // 仅更新允许动态变更的字段
        encodeConfig.rcParams = BuildInitParams(newConfig).encodeConfig->rcParams; // 码率、QP、VBV
        encodeConfig.gopLength = newConfig.nvuse.gopLength;
        encodeConfig.intraRefreshPeriod = newConfig.nvuse.intraRefreshPeriod;
        encodeConfig.encodeWidth = newConfig.width;
        encodeConfig.encodeHeight = newConfig.height;
        encodeConfig.darWidth = newConfig.width;
        encodeConfig.darHeight = newConfig.height;
        reconfigParams.resetEncoder = 0; // 关键：不重置编码器内部状态，保持参考帧有效性
        reconfigParams.forceIDR = 0;     // 依赖 Intra Refresh 平滑过渡，不强制 IDR

        NVENCSTATUS status = nvenc_.nvEncReconfigureEncoder(encoder_, &reconfigParams);
        if (status == NV_ENC_SUCCESS) {
            current_config_ = newConfig;
            return true;
        }
        // 失败回滚逻辑...
        return false;
    }
};

// ResolutionPolicy.h
struct ResolutionTier {
    int width, height;
    int minBitrateKbps;  // 进入该档位所需最小带宽
    int targetBitrateKbps;
    int maxBitrateKbps;
    int fps;
};

// 预设档位表 (16:9 为例)
const std::vector<ResolutionTier> kTiers = {
    { 1920, 1080, 2500, 3500, 4500, 30 }, // Tier 3: 1080p
    { 1280, 720,  1200, 1800, 2500, 30 }, // Tier 2: 720p
    { 960,  540,  600,  900,  1300, 30 }, // Tier 1: 540p
    { 640,  360,  200,  400,  600,  25 }, // Tier 0: 360p (兜底)
};

class ResolutionController {
    int current_tier_idx_ = 2; // 默认 720p
    int64_t last_switch_time_ms_ = 0;
    const int kMinDwellTimeMs = 3000; // 最小驻留 3s 防抖

    // 滞回判断：升档需带宽 > target * 1.2，降档仅需带宽 < minBitrate * 0.9
    int DecideTargetTier(int64_t estimated_bandwidth_bps, double packet_loss, int rtt_ms) {
        int64_t bw_kbps = estimated_bandwidth_bps / 1000;
        int target = current_tier_idx_;

        // 1. 丢包/延迟保护优先 (强制降档)
        if (packet_loss > 0.1 || rtt_ms > 400) {
            target = std::max(0, current_tier_idx_ - 1);
        } else {
            // 2. 带宽驱动决策
            // 尝试升档
            if (current_tier_idx_ + 1 < kTiers.size()) {
                const auto& next = kTiers[current_tier_idx_ + 1];
                if (bw_kbps > next.targetBitrateKbps * 1.2) target = current_tier_idx_ + 1;
            }
            // 尝试降档
            if (current_tier_idx_ > 0) {
                const auto& cur = kTiers[current_tier_idx_];
                if (bw_kbps < cur.minBitrateKbps * 0.9) target = current_tier_idx_ - 1;
            }
        }

        // 3. 驻留时间保护
        int64_t now = GetCurrentTimeMs();
        if (target != current_tier_idx_ && (now - last_switch_time_ms_ > kMinDwellTimeMs)) {
            return target;
        }
        return current_tier_idx_;
    }

public:
    // 对外接口：由网络监控模块周期性调用
    void OnNetworkMetricsUpdated(int64_t bw_bps, double loss, int rtt) {
        int new_tier = DecideTargetTier(bw_bps, loss, rtt);
        if (new_tier != current_tier_idx_) {
            current_tier_idx_ = new_tier;
            last_switch_time_ms_ = GetCurrentTimeMs();
            // 触发编码器重配置回调
            if (on_reconfig_callback_) on_reconfig_callback_(kTiers[new_tier]);
        }
    }
    std::function<void(const ResolutionTier&)> on_reconfig_callback_;
};

// SvcLayerConfig.h
struct SvcLayerParams {
    // 空间层 (分辨率)
    int spatialId = 0;           // 0: 180p, 1: 360p, 2: 720p, 3: 1080p
    float scaleFactor = 1.0f;    // 相对基础层缩放比
    int targetBitrateKbps = 0;   // 该层目标码率 (含增量)
    int maxBitrateKbps = 0;
    int fps = 30;
    
    // 时间层 (帧率/依赖关系)
    int temporalId = 0;          // T0/T1/T2/T3
    int temporalLayerIdx = 0;    // 0=Base(T0), 1=T1, 2=T2...
    bool isReference = true;     // 是否作为高层参考帧
    
    // NVUSE 专用率控隔离
    struct RcOverride {
        int qpOffset = 0;        // 相对基础层 QP 偏移 (高层通常 +2~+4)
        int vbvBufferScale = 1;  // VBV 缓冲比例
    } rc;
};

// 编码器初始化时构建完整 SVC 结构
NV_ENC_CONFIG_H264 BuildSvcConfig(const EncoderConfig& cfg, const std::vector<SvcLayerParams>& layers) {
    NV_ENC_CONFIG_H264 h264Config = { NV_ENC_CONFIG_H264_VER };
    h264Config.maxTemporalLayers = 4; // 支持 LxT3
    h264Config.maxSpatialLayers = 4;
    
    // 关键：逐层配置率控与 GOP 结构
    for (size_t i = 0; i < layers.size(); ++i) {
        auto& layer = layers[i];
        auto& nl = h264Config.temporalLayer[layer.temporalLayerIdx];
        
        nl.frameRateNum = layer.fps;
        nl.frameRateDen = 1;
        nl.targetBitRate = layer.targetBitrateKbps * 1000;
        nl.maxBitRate = layer.maxBitrateKbps * 1000;
        
        // 时间层依赖模式: NV_ENC_TEMPORAL_LAYER_MODE_XXX
        // T0: Key/Ref, T1: Ref for T2, T2: Ref for T3, T3: Non-ref
        if (layer.temporalId == 0) nl.frameIntervalP = 1; // 基础层全 I/P
        else nl.frameIntervalP = (1 << layer.temporalId); // 高层间隔指数增长
        
        // QP 偏移实现层级画质梯度
        nl.qpOffset = layer.rc.qpOffset; 
    }
    
    // 空间层配置 (Simulcast 或 SVC Spatial)
    // 注意：NVENC 空间分层要求基础层分辨率对齐宏块 (16x16/32x32)
    for (size_t i = 0; i < layers.size(); ++i) {
        if (layers[i].spatialId > 0) {
            auto& sl = h264Config.spatialLayer[layers[i].spatialId];
            sl.width = static_cast<uint32_t>(cfg.width * layers[i].scaleFactor);
            sl.height = static_cast<uint32_t>(cfg.height * layers[i].scaleFactor);
            sl.targetBitRate = layers[i].targetBitrateKbps * 1000;
        }
    }
    return h264Config;
}

// CudaGraphPipeline.cpp
class PreprocessGraph {
    cudaGraph_t graph_ = nullptr;
    cudaGraphExec_t graphExec_ = nullptr;
    cudaStream_t stream_; // 绑定 NVENC 编码流
    
    // 设备端缓冲区 (循环池管理)
    struct BufferSet { CUdeviceptr yuvPtr; int pitch; int w, h; };
    std::vector<BufferSet> bufferPool_;
    std::atomic<int> writeIdx_{0};

public:
    bool Initialize(int maxWidth, int maxHeight, cudaStream_t nvencStream) {
        stream_ = nvencStream;
        // 1. 分配设备端 Buffer Pool (注册为 NVENC Input Resource)
        // 2. 开始捕获 Graph
        cudaStreamBeginCapture(stream_, cudaStreamCaptureModeGlobal);
        
        // 3. 定义节点: 输入纹理 -> Scale/Convert Kernel -> 输出 NV12 Buffer
        //    支持动态参数: 通过 cudaGraphKernelNodeSetAttribute 更新 Kernel 参数 (如 scale factor, roi rect)
        //    示例: nv12ScaleKernel<<<grid, block, 0, stream_>>>(srcTex, dstBuffer, scaleW, scaleH);
        
        // 4. 结束捕获 & 实例化
        cudaStreamEndCapture(stream_, &graph_);
        cudaGraphInstantiate(&graphExec_, graph_, NULL, NULL, 0);
        return true;
    }

    // 每帧调用: 仅更新 Kernel 参数并启动 Graph (极低开销 ~微秒级)
    void ExecuteFrame(CUeglFrame& inputFrame, int targetW, int targetH, CUdeviceptr& outputBuffer, int& outputPitch) {
        int idx = writeIdx_.fetch_add(1) % bufferPool_.size();
        auto& dst = bufferPool_[idx];
        
        // 更新 Graph 中 Kernel 节点的运行时参数 (宽高、指针)
        // 需提前在捕获时记录 kernelNodeHandle
        cudaGraphKernelNodeSetAttribute(kernelNode_, cudaGraphKernelNodeAttributeDevicePointer, &inputFrame);
        // ... 更新其他参数 ...
        
        // 启动 Graph (异步)
        cudaGraphLaunch(graphExec_, stream_);
        
        // 记录完成事件, 供 NVENC 等待 (通过 nvEncEncodePicture 的 inputBuffer 关联 stream 隐式同步)
        outputBuffer = dst.yuvPtr;
        outputPitch = dst.pitch;
    }
};

// EncoderHealthManager.h
enum class EncoderState { HEALTHY, DEGRADED_RETRY, REBUILDING_SESSION, MIGRATING_DEVICE, FALLBACK_CPU };

class EncoderHealthManager {
    EncoderState state_ = EncoderState::HEALTHY;
    int consecutive_errors_ = 0;
    std::chrono::steady_clock::time_point last_rebuild_time_;
    std::shared_ptr<IVideoEncoder> encoder_; // 当前实例
    std::shared_ptr<IVideoEncoder> cpu_fallback_encoder_; // 预热好的 CPU 编码器
    EncoderConfig current_config_;

    // 统一错误入口
    void OnEncodeError(NVENCSTATUS status, const EncodedFrame* frame) {
        if (IsTransientError(status)) {
            HandleTransient(status);
        } else if (IsSessionFatal(status)) {
            HandleSessionFatal();
        } else if (IsDeviceFatal(status)) {
            HandleDeviceFatal();
        }
    }

    void HandleSessionFatal() {
        if (state_ == EncoderState::REBUILDING_SESSION) return; // 防抖
        state_ = EncoderState::REBUILDING_SESSION;
        LOG(WARNING) << "NVENC Session Fatal, triggering rebuild...";
        
        // 异步重建任务 (避免阻塞网络线程)
        thread_pool_.PostTask([this]() {
            // 1. 清理旧资源
            if (encoder_) encoder_->Release();
            
            // 2. 重建 CUDA Context (关键：必须重建，旧 Context 已污染)
            RecreateCudaContext();
            
            // 3. 重新初始化 NVENC
            auto newEncoder = std::make_shared<NvuseEncoderAdapter>();
            if (newEncoder->Initialize(current_config_)) {
                // 4. 原子切换指针 (无锁)
                encoder_ = std::move(newEncoder);
                state_ = EncoderState::HEALTHY;
                consecutive_errors_ = 0;
                
                // 5. 强制请求 IDR (通过 WebRTC 回调或下一帧 forceKeyFrame=true)
                RequestKeyFrameImmediately(); 
                LOG(INFO) << "NVENC Session Rebuild Success.";
            } else {
                // 重建失败 -> 触发设备级迁移或 CPU 降级
                EscalateToDeviceMigrationOrFallback();
            }
        });
    }

    void HandleDeviceFatal() {
        state_ = EncoderState::MIGRATING_DEVICE;
        // 上报控制平面: 标记当前 GPU 不健康, 触发 Pod 迁移/重调度
        control_plane_client_->ReportGpuUnhealthy(gpu_id_, "NVENC Device Lost");
        // 启动 CPU 兜底编码维持信令连接
        ActivateCpuFallback();
    }
    
    // 对外提供编码器实例获取 (双缓冲/原子指针保证线程安全)
    std::shared_ptr<IVideoEncoder> GetActiveEncoder() {
        return std::atomic_load(&encoder_);
    }
};

# 关键指标定义 (Metrics Naming Convention: nvuse_encoder_<subsystem>_<metric>)
# 1. 吞吐与性能
- nvuse_encoder_throughput_fps{job="media-server", gpu_id="0", codec="h264"}  # 实时编码帧率
- nvuse_encoder_latency_us{quantile="0.5|0.95|0.99"} # 编码耗时分位数 (Enqueue -> OutputReady)
- nvuse_encoder_gpu_util_percent{gpu_id="0", engine="nvenc"} # NVENC 硬件利用率 (NVML 采集)

# 2. 质量与自适应
- nvuse_encoder_target_bitrate_kbps{layer="spatial_0|temporal_0"} # 当前生效码率
- nvuse_encoder_actual_bitrate_kbps # 实际输出码率 (滑动窗口 1s)
- nvuse_encoder_resolution_switch_total{from="1080p", to="720p", reason="bwe_drop|cpu_load|manual"} # 切换计数与原因
- nvuse_encoder_intra_refresh_cycles_total # 循环内刷完成周期数 (监控 SVC/切换健康度)

# 3. 错误与健康度
- nvuse_encoder_errors_total{code="OUT_OF_MEMORY|INVALID_PARAM|DEVICE_LOST|RECONFIG_FAILED", level="L0|L1|L2"}
- nvuse_encoder_rebuild_session_total # Session 重建次数
- nvuse_encoder_fallback_cpu_active{bool="true|false"} # 是否触发 CPU 兜底

# 4. 显存精细化
- nvuse_encoder_vram_allocated_bytes{pool="input|output|preprocess"} 
- nvuse_encoder_vram_fragmentation_ratio # 碎片率 (自定义 Collector 计算)