// 1. 获取摄像头轨道
const track = (await navigator.mediaDevices.getUserMedia({ video: true })).getVideoTracks()[0];

// 2. 创建 PeerConnection 并启用 Insertable Streams
const pc = new RTCPeerConnection({ encodedInsertableStreams: true });

// 3. 定义水印 Transformer（WebGL 离屏渲染）
class WatermarkTransformer {
  constructor() { this.canvas = new OffscreenCanvas(1280, 720); this.ctx = this.canvas.getContext('2d'); }
  transform(frame, controller) {
    // frame 为 VideoFrame 对象
    this.ctx.drawImage(frame, 0, 0);
    this.ctx.fillStyle = 'rgba(255,255,255,0.5)';
    this.ctx.font = '24px sans-serif';
    this.ctx.fillText('CONFIDENTIAL', 20, 40);
    controller.enqueue(new VideoFrame(this.canvas, { timestamp: frame.timestamp }));
    frame.close(); // 释放原帧内存
  }
}

// 4. 接入管道
const sender = pc.addTrack(track);
const { readable, writable } = sender.insertableStreams;
readable
  .pipeThrough(new TransformStream(new WatermarkTransformer()))
  .pipeTo(writable);

const receiver = pc.getReceivers().find(r => r.track.kind === 'video');
const { readable, writable } = receiver.insertableStreams;

class DecryptTransformer {
  constructor(key) { this.key = key; }
  async transform(chunk, controller) {
    // chunk 为 EncodedVideoChunk（含加密载荷）
    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: chunk.iv }, this.key, chunk.data);
    controller.enqueue(new EncodedVideoChunk({
      type: chunk.type,
      timestamp: chunk.timestamp,
      data: decrypted,
      duration: chunk.duration
    }));
  }
}

readable
  .pipeThrough(new TransformStream(new DecryptTransformer(key)))
  .pipeTo(writable);

interface MediaPlugin {
  id: string;                 // 唯一标识，如 "com.example.bg-blur"
  name: string;               // 显示名称
  version: string;            // 语义化版本
  kind: 'video' | 'audio' | 'data';
  position: 'pre-encode' | 'post-decode'; // 插入位置
  entry: string;              // ES Module 入口，导出 Transformer 类
  permissions: ('camera' | 'microphone' | 'gpu' | 'wasm-simd')[]; // 权限声明
  configSchema: JSONSchema;   // 运行时配置校验
  performanceHint: {          // 性能提示，供调度器决策
    avgMsPerFrame: number;
    maxResolution: { width: number; height: number };
    gpuMemoryMB?: number;
  };
}

{
  "pipelineId": "meeting-standard-v3",
  "nodes": [
    { "id": "denoise", "kind": "audio", "position": "pre-encode", "entry": "plugins/denoise-rnnoise.wasm", "parallelGroup": "audio-pre" },
    { "id": "agc", "kind": "audio", "position": "pre-encode", "entry": "plugins/agc-webcodecs.js", "parallelGroup": "audio-pre", "dependsOn": ["denoise"] },
    { "id": "bg-blur", "kind": "video", "position": "pre-encode", "entry": "plugins/mediapipe-seg.wasm", "parallelGroup": "video-pre", "gpu": "prefer-webgpu" },
    { "id": "watermark", "kind": "video", "position": "pre-encode", "entry": "plugins/watermark-gl.js", "dependsOn": ["bg-blur"] },
    { "id": "e2ee-encrypt", "kind": "data", "position": "pre-encode", "entry": "plugins/e2ee-aesgcm.js", "dependsOn": ["watermark", "agc"] }
  ],
  "schedulingPolicy": "lowest-latency-first"
}

class PipelineScheduler {
  // 拓扑排序 + 资源感知调度
  buildPipeline(graph: PTDLGraph, mediaTrack: MediaStreamTrack): TransformStream {
    const sorted = this.topoSort(graph.nodes);
    const streams = new Map<string, TransformStream>();

    // 1. 创建并行组共享 Worker/GPU Context
    const parallelGroups = this.groupBy(sorted, n => n.parallelGroup);
    parallelGroups.forEach(group => {
      group.forEach(node => {
        const worker = this.getOrCreateWorker(node.entry, node.gpu);
        streams.set(node.id, this.wrapWorkerAsTransformStream(worker, node.config));
      });
    });

    // 2. 按依赖链接 pipeThrough
    let head: ReadableStream | WritableStream = mediaTrack;
    sorted.forEach(node => {
      const ts = streams.get(node.id)!;
      if (node.dependsOn?.length) {
        // 合并多前驱：使用 TransformStreamIdentity 作为汇聚点
        head = this.mergeStreams(node.dependsOn.map(d => streams.get(d)!)).pipeThrough(ts);
      } else {
        head = (head as ReadableStream).pipeThrough(ts);
      }
    });

    return head as TransformStream;
  }

  // 关键优化：零拷贝合并多路流（同分辨率/时间基）
  private mergeStreams(streams: ReadableStream[]): ReadableStream {
    return new ReadableStream({
      start(controller) {
        streams.forEach(s => s.getReader().read().then(({ value, done }) => {
          if (!done) controller.enqueue(value);
        }));
      }
    });
  }
}

graph TD
    App[业务层: MeetingSDK] --> Adapter[MediaPipelineAdapter]
    Adapter -->|Insertable Streams| ChromeImpl[ChromePipelineImpl]
    Adapter -->|WebCodecs + SFU Sidecar| SafariImpl[SafariPipelineImpl]
    Adapter -->|Native Module (C++/Rust)| NativeImpl[NativePipelineImpl]
    ChromeImpl --> Core[Core Transformer Registry]
    SafariImpl --> Core
    NativeImpl --> Core

interface IMediaPipeline {
  // 统一入口：插件清单 -> 返回可挂载的 TransformStream 对
  createProcessor(track: MediaStreamTrack, plugins: PluginManifest[]): Promise<{
    readable: ReadableStream;
    writable: WritableStream;
    // 统一控制面
    control: {
      updateConfig: (pluginId: string, config: any) => void;
      enable: (pluginId: string, enabled: boolean) => void;
      getMetrics: () => PluginMetrics[];
    };
  }>;
  
  // 能力探测
  getCapabilities(): PipelineCapabilities;
}

// Safari 降级实现：将视频流转发至 SFU 侧 Worker 处理，再拉回渲染
class SafariPipelineImpl implements IMediaPipeline {
  async createProcessor(track, plugins) {
    // 1. 本地渲染预览（无处理）
    // 2. 信令协商：要求 SFU 插入对应处理节点
    await this.signalClient.requestServerSideProcessing(plugins.map(p => p.id));
    // 3. 返回透传流（本地不做处理）
    return this.createPassthroughStream(track);
  }
}

graph LR
    Model[模型] --> Runtime{运行时选择}
    Runtime -->|WebGPU 可用| WebGPU[webgpu-onnx / webnn]
    Runtime -->|仅 WASM SIMD| WASM[ort-wasm-simd / tfjs-wasm]
    Runtime -->|仅 WASM 基础| WASM_Base[ort-wasm / tfjs-wasm-no-simd]
    Runtime -->|Native 环境| Native[ONNX Runtime C API / MNN / NCNN]

// MediaSoup Worker 侧伪代码
struct PluginPipeline {
    // 共享 GPU Context (Vulkan/VA-API/CUDA)
    gpu_ctx: Arc<GpuContext>,
    // 插件链：Watermark -> Transcode -> Record
    stages: Vec<Box<dyn MediaStage>>,
}

impl MediaStage for WatermarkStage {
    fn process(&mut self, frame: &mut VideoFrame) -> Result<()> {
        // 使用共享 GPU 纹理零拷贝叠加水印
        self.gpu_ctx.blit_with_shader(&frame.texture, &self.watermark_texture);
        Ok(())
    }
}

// 客户端自适应控制器
class AdaptiveController {
  onMetrics(metrics: SessionMetrics) {
    // 1. 热度评分
    const thermal = navigator.deviceMemory < 4 ? 'high' : 'normal';
    
    // 2. 决策引擎
    if (metrics.transformerLatencyP99 > 28 || thermal === 'high') {
      this.pluginManager.downgrade('bg-blur', 'model-lite'); // 切轻量模型
      this.pluginManager.disable('super-resolution');         // 关非核心
      this.encoderController.requestKeyFrame();               // 恢复画质
    }
    
    // 3. 网络拥塞联动
    if (metrics.availableOutgoingBitrate < 500_000) { // < 500kbps
      this.pluginManager.disable('virtual-background'); // 省上行带宽
      this.sender.setParameters({ encodings: [{ scaleResolutionDownBy: 2.0 }] });
    }
  }
}