// 简化的编码流程
const encoder = new VideoEncoder({
  output: handleChunk,
  error: handleError
});

encoder.configure({ codec: 'avc1.42001e', width: 1280, height: 720, bitrate: 2_000_000 });

// 核心调用点
encoder.encode(frame, { keyFrame: false });
frame.close(); // 及时释放内存

class FrameQoSController {
  constructor(encoder) {
    this.encoder = encoder;
    this.pendingFrames = new Map(); // timestamp -> { frame, isKey, deps }
  }

  // 编码入口拦截
  tryEncode(frame, options) {
    const queueSize = this.encoder.encodeQueueSize;
    
    // L2/L3 级别强制丢帧逻辑
    if (queueSize >= 4) {
      return this.dropRedundantFrames(frame, queueSize);
    }
    
    // 正常入队
    this.pendingFrames.set(frame.timestamp, { frame, isKey: options.keyFrame, deps: [] });
    this.encoder.encode(frame, options);
  }

  dropRedundantFrames(newFrame, queueSize) {
    // 策略：保留最新关键帧，丢弃中间非参考P/B帧，保留最新P帧用于运动预测
    // 1. 识别可丢弃帧：非关键帧、非最新帧、无后续帧依赖的帧
    // 2. 批量 close() 释放内存
    // 3. 仅编码新帧或最近的关键帧
    
    let dropped = 0;
    for (const [ts, entry] of this.pendingFrames) {
      if (!entry.isKey && ts !== this.getLatestTimestamp() && dropped < queueSize - 2) {
        entry.frame.close();
        this.pendingFrames.delete(ts);
        dropped++;
      }
    }
    // 编码新帧
    this.encoder.encode(newFrame, { keyFrame: false });
  }
}

class KeyFrameScheduler {
  constructor(encoder, networkController) {
    this.encoder = encoder;
    this.netCtrl = networkController;
    this.pendingKeyFrameRequest = false;
    this.lastKeyFrameTs = 0;
  }

  requestKeyFrame(reason, priority = 'normal') {
    const queueSize = this.encoder.encodeQueueSize;
    const estimatedKeyFrameSize = this.estimateKeyFrameSize(); // 基于历史统计
    const availableBandwidth = this.netCtrl.getAvailableBitrate(); // bps
    
    // 决策矩阵
    if (priority === 'urgent') { // PLI/新用户
      // 即使拥塞也要发，但需清理队列腾空间
      this.forceFlushAndEncodeKeyFrame();
      return;
    }

    // 普通/恢复/定时请求：回压感知决策
    const timeSinceLastKey = performance.now() - this.lastKeyFrameTs;
    const minInterval = 1000; // 最小间隔 1s

    // 条件1：距离上一关键帧太近 -> 合并请求
    if (timeSinceLastKey < minInterval) {
      this.pendingKeyFrameRequest = true;
      return;
    }

    // 条件2：队列拥塞 -> 延后发送，标记待定
    if (queueSize > 2) {
      this.pendingKeyFrameRequest = true;
      // 启动定时器，待队列消退后尝试
      this.scheduleRetryWhenIdle();
      return;
    }

    // 条件3：带宽窗口不足 -> 关键帧可能撑爆发送缓冲区
    // 简单启发式：关键帧大小 > 当前发送缓冲剩余量 / 2
    if (estimatedKeyFrameSize > this.netCtrl.getSendBufferAvailable() * 0.5) {
      this.pendingKeyFrameRequest = true;
      return;
    }

    // 条件满足：立即执行
    this.executeKeyFrameEncode();
  }

  executeKeyFrameEncode() {
    // 获取最新一帧原始数据（需应用层缓存最新 VideoFrame 或重新捕获）
    const latestFrame = this.getLatestRawFrame(); 
    if (!latestFrame) return;

    this.encoder.encode(latestFrame, { keyFrame: true });
    this.lastKeyFrameTs = performance.now();
    this.pendingKeyFrameRequest = false;
  }

  // 编码器输出回调中监听关键帧产出
  onEncodedChunk(chunk) {
    if (chunk.type === 'key') {
      this.lastKeyFrameTs = performance.now();
      // 通知网络层：大帧来了，预留带宽/调整发包节奏
      this.netCtrl.onKeyFrameProduced(chunk.byteLength);
    }
  }
}

// 配置 3 层时域分层 (L1T3): 基础层 7.5fps, 中层 15fps, 顶层 30fps
// 依赖关系: L0 (Key) -> L1 -> L2 -> L1 -> L2 ... (参考结构由编码器内部管理)
const encoder = new VideoEncoder({ output, error });
encoder.configure({
  codec: 'avc1.42E01F', // H.264 Baseline/Constrained Baseline 支持 SVC
  width: 1280,
  height: 720,
  bitrate: 2_500_000,    // 目标总码率
  framerate: 30,
  scalabilityMode: 'L1T3', // 关键：启用 1 空间层 x 3 时间层
  latencyMode: 'realtime'
});

let frameCounter = 0;
const temporalPattern = [0, 2, 1, 2]; // L1T3 典型参考模式: L0, L2, L1, L2...

function feedEncoder(frame) {
  const temporalId = temporalPattern[frameCounter % temporalPattern.length];
  
  // 策略：回压严重时，仅提交 temporalId === 0 的帧 (基础层)
  if (qosController.isSevereCongestion() && temporalId !== 0) {
    frame.close(); // 直接丢弃增强层输入帧，不入编码队列
    return;
  }

  encoder.encode(frame, { 
    keyFrame: (temporalId === 0 && frameCounter % 30 === 0), // 仅基础层发 IDR
    // 注意：WebCodecs 当前未直接暴露 temporalId 设置，依赖编码器内部模式自动生成
  });
  frameCounter++;
}

// 解析输出分层信息，供 SFU 转发决策
function handleChunk(chunk, metadata) {
  // metadata: { temporalId: 0, spatialId: 0, ... } (Chrome 113+ 支持)
  const layerId = metadata.temporalId ?? 0; 
  sfuSender.send(chunk, { layerId, isKey: chunk.type === 'key' });
}

graph LR
    A[MediaStreamTrack] --> B(VideoTrackProcessor)
    B --> C{ReadableStream<VideoFrame>}
    C --> D[WebGPU ImportExternalTexture]
    D --> E[Compute Shader: Denoise/Beauty/Blur]
    E --> F[GPU Texture Output]
    F --> G[VideoFrame.from GPUTexture]
    G --> H[VideoEncoder.encode]

// 1. 从 ReadableStream 获取 GPU 布局的 VideoFrame
const trackProcessor = new MediaStreamTrackProcessor({ track: videoTrack });
const reader = trackProcessor.readable.getReader();

const gpuContext = await setupWebGPU(); // device, context, format: 'rgba8unorm'

async function gpuProcessLoop() {
  while (true) {
    const { done, value: frame } = await reader.read();
    if (done) break;

    // 2. 零拷贝导入外部纹理 (需 frame.format 兼容)
    const externalTexture = gpuContext.device.importExternalTexture({
      source: frame, // 直接传入 VideoFrame
      colorSpace: 'srgb',
      premultipliedAlpha: true
    });

    // 3. 计算着色器处理 (示例: 双边滤波降噪 + ROI 锐化)
    const commandEncoder = gpuContext.device.createCommandEncoder();
    const computePass = commandEncoder.beginComputePass();
    computePass.setPipeline(gpuContext.denoisePipeline);
    computePass.setBindGroup(0, gpuContext.bindGroupLayout, [
      externalTexture, 
      gpuContext.outputTextureView, 
      gpuContext.uniformBuffer // 传入人脸关键点 ROI 区域
    ]);
    computePass.dispatchWorkgroups(Math.ceil(frame.codedWidth/16), Math.ceil(frame.codedHeight/16));
    computePass.end();
    
    // 4. 同步点：插入 Fence 确保 GPU 完成再交给编码器
    // 注意：WebCodecs 编码器接受 GPU VideoFrame 需要设备支持
    const outputFrame = new VideoFrame(gpuContext.outputTexture, {
      timestamp: frame.timestamp,
      format: 'RGBA8Unorm' // 需与 encoder.configure 一致
    });
    
    frame.close(); // 释放输入帧资源
    encoder.encode(outputFrame, { keyFrame: false });
    outputFrame.close(); // encode 后立即 close
  }
}

enum EncoderState {
  UNINITIALIZED = 'UNINITIALIZED',
  CONFIGURING   = 'CONFIGURING',
  RUNNING       = 'RUNNING',
  DRAINING      = 'DRAINING',   // flush() 进行中
  RECONFIGURING = 'RECONFIGURING', // configure() 变更中
  ERROR         = 'ERROR',
  CLOSED        = 'CLOSED'
}

class ResilientVideoEncoder {
  private state: EncoderState = EncoderState.UNINITIALIZED;
  private encoder: VideoEncoder | null = null;
  private config: VideoEncoderConfig;
  private frameBuffer: VideoFrame[] = []; // 状态切换时的帧缓冲

  // 状态迁移守卫
  private transition(targetState: EncoderState, action: () => Promise<void>) {
    const validTransitions: Record<EncoderState, EncoderState[]> = {
      [EncoderState.UNINITIALIZED]: [EncoderState.CONFIGURING],
      [EncoderState.CONFIGURING]: [EncoderState.RUNNING, EncoderState.ERROR],
      [EncoderState.RUNNING]: [EncoderState.DRAINING, EncoderState.RECONFIGURING, EncoderState.ERROR, EncoderState.CLOSED],
      [EncoderState.DRAINING]: [EncoderState.RUNNING, EncoderState.ERROR, EncoderState.CLOSED],
      [EncoderState.RECONFIGURING]: [EncoderState.RUNNING, EncoderState.ERROR],
      [EncoderState.ERROR]: [EncoderState.CONFIGURING, EncoderState.CLOSED], // 仅允许重试或关闭
      [EncoderState.CLOSED]: []
    };
    
    if (!validTransitions[this.state].includes(targetState)) {
      throw new Error(`非法状态迁移: ${this.state} -> ${targetState}`);
    }
    this.state = targetState;
    return action();
  }

  async init(config: VideoEncoderConfig) {
    this.config = config;
    await this.transition(EncoderState.CONFIGURING, async () => {
      const support = await VideoEncoder.isConfigSupported(config);
      if (!support.supported) throw new Error('Config not supported');
      
      this.encoder = new VideoEncoder({
        output: this.handleOutput.bind(this),
        error: this.handleError.bind(this) // 关键：统一错误入口
      });
      this.encoder.configure(config);
      // 等待首帧输出或配置确认信号...
    });
    this.state = EncoderState.RUNNING;
    this.drainBufferedFrames(); // 释放初始化期间积压的帧
  }

  // 核心异常处理：分类、上报、自愈决策
  private handleError(error: DOMException) {
    console.error('[Encoder] Fatal Error:', error.name, error.message);
    
    // 分类策略
    switch (error.name) {
      case 'EncodingError': // 编码器内部错误，通常可恢复
      case 'OperationError': // 操作非法，可能配置问题
        this.scheduleRecovery(RecoveryStrategy.REINIT_SAME_CONFIG);
        break;
      case 'NotSupportedError': // 配置不支持，需降级
        this.scheduleRecovery(RecoveryStrategy.FALLBACK_CONFIG);
        break;
      case 'QuotaExceededError': // 显存/资源耗尽
        this.scheduleRecovery(RecoveryStrategy.REDUCE_RESOLUTION);
        break;
      default:
        this.scheduleRecovery(RecoveryStrategy.FULL_RESET);
    }
    this.transition(EncoderState.ERROR, () => {});
  }

  private async scheduleRecovery(strategy: RecoveryStrategy) {
    // 指数退避重试，避免风暴
    const delay = Math.min(1000 * Math.pow(2, this.retryCount), 30000);
    await new Promise(r => setTimeout(r, delay));
    
    try {
      switch(strategy) {
        case RecoveryStrategy.REINIT_SAME_CONFIG:
          await this.reinitEncoder(this.config);
          break;
        case RecoveryStrategy.FALLBACK_CONFIG:
          const fallback = this.generateFallbackConfig(this.config);
          await this.reinitEncoder(fallback);
          break;
        // ...
      }
      this.emit('recovered', strategy);
    } catch (e) {
      this.scheduleRecovery(RecoveryStrategy.FULL_RESET); // 终极兜底
    }
  }
}

const GOLDEN_CONFIG_1080P = {
  codec: 'avc1.42001e',        // H.264 Baseline: 兼容性最强、延迟最低、无 B 帧
  width: 1920,
  height: 1080,
  bitrate: 3_000_000,          // 目标 3Mbps, 配合 VBR 上限 4.5Mbps
  framerate: 30,
  latencyMode: 'realtime',     // 关键：强制超低延迟模式
  scalabilityMode: 'L1T2',     // 双层时域: 15fps/30fps 无缝降级
  // 进阶参数 (Chrome 扩展/私有，需特性检测)
  // avc: { level: '3.1', profile: 'baseline' }, 
  // bitrateMode: 'variable',   // VBR 更省带宽，CBR 更利于弱网 Pacer
  // keyFrameInterval: 30       // 1s 一个 IDR，平衡随机接入与开销
};