const getVideoConstraints = (isHighDefinition = false) => ({
  video: {
    // 宽高比约束，避免极端长宽比导致编码异常
    aspectRatio: { ideal: 16 / 9 },
    // 分辨率阶梯：理想值 -> 可接受范围
    width: { ideal: isHighDefinition ? 1920 : 1280, max: 1920, min: 640 },
    height: { ideal: isHighDefinition ? 1080 : 720, max: 1080, min: 360 },
    // 帧率：屏幕内容变化慢，15fps 通常足够；远程桌面操作建议 30fps
    frameRate: { ideal: 15, max: 30 },
    // 关键：显式声明不需要光标（部分场景），减少带宽
    // cursor: 'never' | 'always' | 'motion' 
  },
  audio: {
    // 回声消除、噪音抑制对系统音频通常无效，但保留以兼容麦克风混音场景
    echoCancellation: true,
    noiseSuppression: true,
    autoGainControl: true
  },
  preferCurrentTab: true,
  selfBrowserSurface: 'exclude', // 核心自排除开关
  systemAudio: 'include',
  surfaceSwitching: 'include'
});

class SelfCaptureDetector {
  constructor(videoElement, options = {}) {
    this.video = videoElement;
    this.canvas = document.createElement('canvas');
    this.ctx = this.canvas.getContext('2d', { willReadFrequently: true });
    this.markerId = `self-capture-marker-${Date.now()}-${Math.random()}`;
    this.checkInterval = options.checkInterval || 2000; // 2s 轮询
    this.similarityThreshold = options.similarityThreshold || 0.98;
  }

  // 1. 在当前页面注入不可见特征标记
  injectMarker() {
    const marker = document.createElement('div');
    marker.id = this.markerId;
    marker.style.cssText = `
      position: fixed; top: 0; left: 0; width: 16px; height: 16px; 
      pointer-events: none; opacity: 0.01; z-index: 2147483647;
      background: linear-gradient(45deg, #ff0000 25%, #00ff00 25%, #00ff00 50%, #ff0000 50%, #ff0000 75%, #00ff00 75%, #00ff00 100%);
      background-size: 4px 4px;
      animation: markerMove 1s linear infinite;
    `;
    // 动态注入 keyframes 避免 CSS 污染
    const style = document.createElement('style');
    style.textContent = `@keyframes markerMove { 0% { background-position: 0 0; } 100% { background-position: 4px 4px; } }`;
    document.head.appendChild(style);
    document.body.appendChild(marker);
  }

  // 2. 启动检测循环
  startDetection(onDetected) {
    this.injectMarker();
    this.timer = setInterval(() => this._checkFrame(onDetected), this.checkInterval);
  }

  _checkFrame(callback) {
    if (this.video.readyState < this.video.HAVE_CURRENT_DATA) return;
    
    this.canvas.width = this.video.videoWidth;
    this.canvas.height = this.video.videoHeight;
    this.ctx.drawImage(this.video, 0, 0);
    
    // 仅采样左上角 16x16 区域，极低性能开销
    const imageData = this.ctx.getImageData(0, 0, 16, 16).data;
    const markerData = this._getExpectedMarkerData(); // 预计算标记像素特征
    
    if (this._comparePixels(imageData, markerData) > this.similarityThreshold) {
      this.stopDetection();
      callback && callback(); // 触发自采集回调
    }
  }

  _comparePixels(data1, data2) {
    let match = 0;
    for (let i = 0; i < data1.length; i += 4) {
      // 简单 RGB 差值比对，容忍压缩损耗
      const dr = Math.abs(data1[i] - data2[i]);
      const dg = Math.abs(data1[i+1] - data2[i+1]);
      const db = Math.abs(data1[i+2] - data2[i+2]);
      if (dr < 30 && dg < 30 && db < 30) match++;
    }
    return match / (data1.length / 4);
  }

  stopDetection() {
    clearInterval(this.timer);
    const el = document.getElementById(this.markerId);
    el?.remove();
  }
}

async function startScreenShareWithFallback() {
  const constraints = getVideoConstraints();
  let stream;
  
  try {
    stream = await navigator.mediaDevices.getDisplayMedia(constraints);
    const videoTrack = stream.getVideoTracks()[0];
    
    // 1. 首选：读取 displaySurface (Chrome 100+, Firefox, Safari 15+)
    const settings = videoTrack.getSettings();
    if (settings.displaySurface === 'browser') {
      console.warn('[ScreenShare] 检测到 displaySurface=browser，疑似自采集');
      return handleSelfCapture(stream); // 引导重选
    }

    // 2. 兜底：启动 Canvas 像素检测
    const detector = new SelfCaptureDetector(videoElement);
    detector.startDetection(() => handleSelfCapture(stream));

    return stream;
  } catch (err) {
    // 处理 NotAllowedError, NotFoundError 等
    throw err;
  }
}

function handleSelfCapture(stream) {
  stream.getTracks().forEach(t => t.stop()); // 立即停止当前流
  // 业务层弹窗提示："检测到您选择了当前会议页面，请重新选择其他窗口或屏幕"
  // 可提供 "重新选择" 按钮再次调用 getDisplayMedia
}

const ScreenCaptureCaps = {
  // 探测 selfBrowserSurface 支持
  async supportSelfBrowserExclude() {
    try {
      // 尝试调用，若浏览器不识别字段通常会忽略或抛出 TypeError
      // 注意：无法同步探测，需结合 UA 白名单或尝试调用后观察行为
      const stream = await navigator.mediaDevices.getDisplayMedia({
        video: true,
        selfBrowserSurface: 'exclude',
        preferCurrentTab: true
      });
      stream.getTracks().forEach(t => t.stop());
      return true;
    } catch (e) {
      return false; // 或根据 e.name 判断
    }
  },

  // 探测 systemAudio 支持
  supportSystemAudio() {
    return 'systemAudio' in navigator.mediaDevices.getDisplayMedia?.toString() || 
           /Chrome/(d+)/.test(navigator.userAgent) && parseInt(RegExp.$1) >= 105;
  },

  // 探测 surfaceSwitching 支持
  supportSurfaceSwitching() {
    return /Chrome/(d+)/.test(navigator.userAgent) && parseInt(RegExp.$1) >= 112;
  }
};

class ScreenShareController {
  constructor() {
    this.stream = null;
    this.detector = null;
    this.videoEl = document.createElement('video');
    this.videoEl.muted = true; // 本地预览必须静音
    this.videoEl.playsInline = true;
  }

  async start() {
    if (this.stream) return this.stream;
    
    this.stream = await startScreenShareWithFallback(); // 含自排除逻辑
    this.videoEl.srcObject = this.stream;
    await this.videoEl.play().catch(() => {}); // 忽略自动播放策略拦截
    
    // 监听轨道结束（用户点击浏览器原生停止共享按钮）
    this.stream.getVideoTracks()[0].addEventListener('ended', () => this._onTrackEnded());
    
    return this.stream;
  }

  _onTrackEnded() {
    this.detector?.stopDetection();
    this.stream = null;
    this.videoEl.srcObject = null;
    this.emit('stopped'); // 通知业务层更新 UI
  }

  stop() {
    this.stream?.getTracks().forEach(t => t.stop());
    this._onTrackEnded();
  }
}

// 获取真实物理分辨率与设备像素比 (DPR)
function getPhysicalVideoMeta(track) {
  const settings = track.getSettings();
  const { width, height } = settings;
  
  // 关键：videoWidth/videoHeight 为编码器输出的物理像素宽高
  // 但 track.getSettings() 在某些浏览器(如 macOS Chrome)返回的是逻辑像素
  // 需结合 videoElement.videoWidth 校准
  const videoEl = document.createElement('video');
  videoEl.srcObject = new MediaStream([track]);
  await videoEl.play();
  
  const physicalWidth = videoEl.videoWidth;
  const physicalHeight = videoEl.videoHeight;
  const logicalWidth = settings.width;
  const logicalHeight = settings.height;
  
  // 计算真实 DPR (设备像素比)
  const dprX = physicalWidth / logicalWidth;
  const dprY = physicalHeight / logicalHeight;
  
  return {
    physical: { width: physicalWidth, height: physicalHeight },
    logical: { width: logicalWidth, height: logicalHeight },
    dpr: { x: dprX, y: dprY }, // 非均匀缩放场景 x/y 可能不同
    displaySurface: settings.displaySurface
  };
}

// 业务坐标 -> 视频轨道物理坐标
function mapBusinessRectToTrackRect(businessRect, trackMeta, targetWindow) {
  // 1. 业务 CSS 坐标 -> 目标窗口客户区逻辑坐标
  //    需扣除浏览器边框、标题栏、开发工具栏高度 (无标准 API，需启发式或 Native 通信获取)
  const chromeOffsets = estimateBrowserChromeOffsets(targetWindow); 
  
  const logicalInWindow = {
    x: businessRect.x + chromeOffsets.left,
    y: businessRect.y + chromeOffsets.top,
    width: businessRect.width,
    height: businessRect.height
  };

  // 2. 逻辑坐标 -> 物理坐标 (乘以 DPR)
  return {
    x: Math.round(logicalInWindow.x * trackMeta.dpr.x),
    y: Math.round(logicalInWindow.y * trackMeta.dpr.y),
    width: Math.round(logicalInWindow.width * trackMeta.dpr.x),
    height: Math.round(logicalInWindow.height * trackMeta.dpr.y)
  };
}

graph LR
    A[getDisplayMedia AudioTrack] --> B(MediaStreamAudioSourceNode)
    B --> C[GainNode: 统一增益归一化 -18dBFS]
    C --> D{业务开关}
    D -- 会议模式 --> E[WebRTC AEC Node: 回声消除]
    D -- 直播/录制模式 --> F[Bypass AEC: 保真度优先]
    E --> G[DynamicsCompressorNode: 防炸音/限幅]
    F --> G
    G --> H[AnalyserNode: 实时音量/静音检测]
    H --> I[MediaStreamAudioDestinationNode]
    I --> J[RTCPeerConnection.addTrack]

// 合规配置生成器
function createCompliantConstraints(userConsent) {
  const base = { video: true, audio: false }; // 默认关闭音频
  
  if (userConsent.systemAudio) {
    base.audio = { 
      systemAudio: 'require', // 强制要求，失败则中断，避免静默失败
      // 广告法合规：不得承诺“完美录制系统声音”，文案用“尝试采集”
    };
  }
  
  // 敏感场景：文档编辑、代码 IDE、银行页面 -> 建议仅共享窗口而非全屏
  if (userConsent.scene === 'document') {
    base.video = { displaySurface: 'window' }; // 强制窗口模式
    base.preferCurrentTab = false;
  }
  
  return base;
}

# .github/workflows/screen-share-e2e.yml
jobs:
  e2e-screen-share:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      # 1. 启动虚拟显示器 (Xvfb) + 窗口管理器 (Fluxbox) + VNC (可选调试)
      - name: Setup Virtual Display
        run: |
          Xvfb :99 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
          fluxbox -display :99 &
          export DISPLAY=:99
          
      # 2. 创建虚拟音频设备 (PipeWire/PulseAudio) 模拟系统声音
      - name: Setup Virtual Audio
        run: |
          pactl load-module module-null-sink sink_name=VirtualSpeaker
          pactl load-module module-remap-source master=VirtualSpeaker.monitor source_name=VirtualMic
          
      # 3. 启动被测应用 & 测试目标窗口 (如一个固定的 HTML 页面播放测试视频)
      - name: Start Test Target
        run: |
          google-chrome-stable --disable-gpu --no-sandbox --headless=new 
            --use-fake-ui-for-media-stream 
            --use-fake-device-for-media-stream 
            --use-file-for-fake-video-capture=test.y4m 
            --use-file-for-fake-audio-capture=test.wav 
            http://localhost:3000/test-target.html &
            
      # 4. 运行 Playwright/Cypress 测试
      - name: Run E2E Tests
        run: npm run test:e2e:screen-share

// tests/screen-share.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Screen Share Engineering Quality Gates', () => {
  
  test('Self-Exclusion: Current tab MUST NOT appear in picker @chrome @firefox @webkit', async ({ page, browserName }) => {
    await page.goto('/meeting-room');
    // 1. 触发分享
    const sharePromise = page.evaluate(() => navigator.mediaDevices.getDisplayMedia({ 
      video: { selfBrowserSurface: 'exclude' }, 
      preferCurrentTab: true 
    }));
    
    // 2. Playwright 无法直接操作原生 Picker，需依赖 --use-fake-ui-for-media-stream
    //    或使用 CDP/DevTools Protocol 模拟选择 (高级用法)
    //    此处假设使用 fake UI 自动选择第一个非当前标签源
    
    const stream = await sharePromise;
    const track = stream.getVideoTracks()[0];
    
    // 3. 断言：采集源不是当前页面 (通过像素特征或 displaySurface 判断)
    const settings = track.getSettings();
    expect(settings.displaySurface).not.toBe('browser'); // 标准属性校验
    
    // 4. 像素级兜底校验 (调用上文 Detector 逻辑)
    const isSelf = await page.evaluate(() => window.__SELF_DETECTOR__.checkOnce());
    expect(isSelf).toBeFalsy();
    
    track.stop();
  });

  test('High DPI: Captured physical resolution matches monitor @chrome', async ({ page }) => {
    // 需在 CI 配置 200% scaling (GDK_SCALE=2, QT_AUTO_SCREEN_SCALE_FACTOR=1)
    await page.goto('/meeting-room');
    const stream = await page.evaluate(() => navigator.mediaDevices.getDisplayMedia({ video: true }));
    const track = stream.getVideoTracks()[0];
    
    // 断言物理分辨率 = 逻辑分辨率 * DPR
    const videoEl = await page.$('video[autoplay]');
    const physicalW = await videoEl.evaluate(el => el.videoWidth);
    expect(physicalW).toBe(3840); // 1920 * 2
    track.stop();
  });

  test('Audio Pipeline: System audio captured & RMS > threshold', async ({ page }) => {
    // 前置：虚拟音频设备播放 1kHz 正弦波 -18dBFS
    await page.evaluate(() => window.__TEST_AUDIO__.playTone(1000, -18));
    
    const stream = await page.evaluate(() => navigator.mediaDevices.getDisplayMedia({ 
      video: true, 
      audio: { systemAudio: 'require' } 
    }));
    
    const audioTrack = stream.getAudioTracks()[0];
    // 使用 AudioContext 分析 RMS
    const rms = await page.evaluate((track) => {
      const ctx = new AudioContext();
      const src = ctx.createMediaStreamSource(new MediaStream([track]));
      const analyser = ctx.createAnalyser();
      analyser.fftSize = 2048;
      src.connect(analyser);
      const data = new Uint8Array(analyser.frequencyBinCount);
      analyser.getByteFrequencyData(data);
      // 简单 RMS 估算
      const sum = data.reduce((a, b) => a + b * b, 0);
      return Math.sqrt(sum / data.length);
    }, audioTrack);
    
    // 断言信号存在 (阈值需根据虚拟设备校准)
    expect(rms).toBeGreaterThan(10); 
    
    audioTrack.stop();
    stream.getVideoTracks()[0].stop();
  });

  test('Performance Baseline: CPU/Memory growth < 10% in 30min @stress', async ({ page }) => {
    // 长时压力测试，监控 performance.measureUserTiming / Chrome DevTools Protocol Metrics
    // 仅在 Nightly/Weekly CI 运行
  });
});