const displayConstraints = {
  video: {
    // 显式声明分辨率上限，避免 4K 屏幕共享导致编码端压力过大
    width: { ideal: 1920, max: 1920 },
    height: { ideal: 1080, max: 1080 },
    frameRate: { ideal: 30, max: 30 },
    // 关键：排除当前标签页，防止“镜中镜”
    selfBrowserSurface: 'exclude',
    // 允许用户中途切换共享源（如从标签页切到窗口）
    surfaceSwitching: true,
    // 仅采集光标，不采集光标周围高亮（视业务而定）
    cursor: 'motion'
  },
  audio: {
    // 采集标签页音频，不采集麦克风
    echoCancellation: false,
    noiseSuppression: false,
    autoGainControl: false
  },
  // 明确声明不采集系统级音频（如系统提示音）
  systemAudio: false,
  // Firefox 兼容性字段
  preferCurrentTab: false
};

// 特性检测：仅在支持时启用
const supportsSelfExclude = 'selfBrowserSurface' in navigator.mediaDevices.getDisplayMedia?.toString() 
  || /Chrome/(d+)/.test(navigator.userAgent) && parseInt(RegExp.$1) >= 105;

const constraints = {
  video: {
    selfBrowserSurface: supportsSelfExclude ? 'exclude' : 'include' // 旧版本回退为 include，配合下层兜底
  }
};

interface SelfCaptureCheckResult {
  isSelfCapture: boolean;
  confidence: number; // 0-1
  reason: string;
}

async function detectSelfCapture(stream: MediaStream): Promise<SelfCaptureCheckResult> {
  const videoTrack = stream.getVideoTracks()[0];
  if (!videoTrack) return { isSelfCapture: false, confidence: 0, reason: '无视频轨道' };

  // 1. 尺寸快速筛选
  const settings = videoTrack.getSettings();
  const viewportWidth = document.documentElement.clientWidth;
  const viewportHeight = document.documentElement.clientHeight;
  const sizeMatch = Math.abs(settings.width - viewportWidth) <= 2 && 
                    Math.abs(settings.height - viewportHeight) <= 2;
  if (!sizeMatch) return { isSelfCapture: false, confidence: 0, reason: '分辨率不匹配' };

  // 2. 像素采样深度校验（低性能开销：每秒 1 次，仅首帧）
  return new Promise(resolve => {
    const canvas = document.createElement('canvas');
    canvas.width = settings.width!;
    canvas.height = settings.height!;
    const ctx = canvas.getContext('2d', { willReadFrequently: true })!;
    const video = document.createElement('video');
    video.srcObject = stream;
    video.muted = true;
    video.playsInline = true;
    video.onloadeddata = () => {
      ctx.drawImage(video, 0, 0);
      const capturedData = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
      
      // 采样当前页面同尺寸区域（避开动态广告/视频区）
      const refCanvas = document.createElement('canvas');
      refCanvas.width = canvas.width;
      refCanvas.height = canvas.height;
      const refCtx = refCanvas.getContext('2d')!;
      refCtx.drawImage(document.documentElement, 0, 0, canvas.width, canvas.height);
      const refData = refCtx.getImageData(0, 0, canvas.width, canvas.height).data;

      // 计算像素级相似度（抽样 1% 像素）
      let same = 0, total = 0;
      for (let i = 0; i < capturedData.length; i += 4 * 100) {
        const rDiff = Math.abs(capturedData[i] - refData[i]);
        const gDiff = Math.abs(capturedData[i+1] - refData[i+1]);
        const bDiff = Math.abs(capturedData[i+2] - refData[i+2]);
        if (rDiff < 5 && gDiff < 5 && bDiff < 5) same++;
        total++;
      }
      const similarity = same / total;
      video.srcObject = null; // 释放
      resolve({
        isSelfCapture: similarity > 0.95,
        confidence: similarity,
        reason: similarity > 0.95 ? `像素相似度 ${(similarity*100).toFixed(1)}%` : '像素差异明显'
      });
    };
    video.play().catch(() => resolve({ isSelfCapture: false, confidence: 0, reason: '播放失败' }));
  });
}

// 使用示例
try {
  const stream = await navigator.mediaDevices.getDisplayMedia(displayConstraints);
  const check = await detectSelfCapture(stream);
  if (check.isSelfCapture) {
    stream.getTracks().forEach(t => t.stop());
    throw new Error(`检测到自采集：${check.reason}，已自动终止`);
  }
  // 正常接入 WebRTC PeerConnection
} catch (e) {
  // 统一错误上报与用户提示
  reportError('SCREEN_SHARE_SELF_CAPTURE', e);
  showToast('检测到您选择了当前页面，请重新选择其他窗口或标签页共享');
}

async function safeGetDisplayMedia(constraints) {
  // 1. 前置引导
  await showModal({
    title: '屏幕共享提示',
    content: '请在弹出的选择器中选择“其他标签页”或“窗口”，<strong>不要选择当前页面</strong>，否则会出现镜像循环。',
    confirmText: '我知道了，开始共享'
  });

  // 2. 监听可见性变化，辅助判断用户是否真打开了选择器
  let userOpenedPicker = false;
  const onVisibilityChange = () => {
    if (document.visibilityState === 'hidden') userOpenedPicker = true;
  };
  document.addEventListener('visibilitychange', onVisibilityChange);

  try {
    const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
    // 3. 兜底：若用户未切出页面却返回了流，大概率是自采集
    if (!userOpenedPicker) {
      console.warn('[ScreenShare] 用户未离开当前页即返回流，疑似自采集');
    }
    return stream;
  } finally {
    document.removeEventListener('visibilitychange', onVisibilityChange);
  }
}

const DisplayMediaCaps = {
  // 检测是否支持 selfBrowserSurface
  get selfBrowserSurface() {
    if (this._selfBrowserSurface !== undefined) return this._selfBrowserSurface;
    try {
      // 通过创建一个无效约束触发 TypeError，捕获错误信息判断字段支持性
      navigator.mediaDevices.getDisplayMedia({ video: { selfBrowserSurface: 'exclude' } });
    } catch (e) {
      this._selfBrowserSurface = !/selfBrowserSurface/.test(e.message);
      return this._selfBrowserSurface;
    }
    this._selfBrowserSurface = true;
    return true;
  },

  // 检测 surfaceSwitching 支持
  get surfaceSwitching() {
    if (this._surfaceSwitching !== undefined) return this._surfaceSwitching;
    this._surfaceSwitching = 'surfaceSwitching' in (navigator.mediaDevices.getDisplayMedia?.toString() || '');
    return this._surfaceSwitching;
  },

  // 检测 systemAudio 支持
  get systemAudio() {
    return /Chrome/(d+)/.test(navigator.userAgent) && parseInt(RegExp.$1) >= 105;
  }
};

function buildDisplayConstraints(options: {
  requireAudio?: boolean;
  maxResolution?: '720p' | '1080p' | '4k';
  allowSwitchSource?: boolean;
  excludeSelf?: boolean;
} = {}) {
  const { requireAudio = true, maxResolution = '1080p', allowSwitchSource = true, excludeSelf = true } = options;
  
  const resMap = { '720p': 1280, '1080p': 1920, '4k': 3840 };
  const maxW = resMap[maxResolution];

  const videoConstraints: any = {
    width: { ideal: maxW, max: maxW },
    height: { ideal: maxW * 9 / 16, max: maxW * 9 / 16 },
    frameRate: { ideal: 30, max: 30 },
    cursor: 'motion'
  };

  // 逐层注入高级特性
  if (excludeSelf && DisplayMediaCaps.selfBrowserSurface) {
    videoConstraints.selfBrowserSurface = 'exclude';
  }
  if (allowSwitchSource && DisplayMediaCaps.surfaceSwitching) {
    videoConstraints.surfaceSwitching = true;
  }
  // Firefox 兼容字段
  if (navigator.userAgent.includes('Firefox')) {
    videoConstraints.preferCurrentTab = false;
  }

  return {
    video: videoConstraints,
    audio: requireAudio ? {
      echoCancellation: false,
      noiseSuppression: false,
      autoGainControl: false
    } : false,
    systemAudio: requireAudio && DisplayMediaCaps.systemAudio
  };
}

// screen-share-analyzer.worker.js
let prevFrameData = null;
let staticFrameCount = 0;
const THRESHOLD_STATIC = 0.005; // 0.5% 像素变动判定为静态
const THRESHOLD_HIGH_MOTION = 0.2; // 20% 判定为高动态

self.onmessage = async (e) => {
  const { type, bitmap } = e.data;
  if (type !== 'analyze') return;

  const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
  const ctx = canvas.getContext('2d');
  ctx.drawImage(bitmap, 0, 0);
  const currData = ctx.getImageData(0, 0, bitmap.width, bitmap.height).data;

  let diffPixels = 0;
  const step = 4 * 50; // 抽样 2% 像素
  if (prevFrameData) {
    for (let i = 0; i < currData.length; i += step) {
      if (Math.abs(currData[i] - prevFrameData[i]) > 10 ||
          Math.abs(currData[i+1] - prevFrameData[i+1]) > 10 ||
          Math.abs(currData[i+2] - prevFrameData[i+2]) > 10) {
        diffPixels++;
      }
    }
    const diffRatio = diffPixels / (currData.length / step);
    
    let scene = 'interactive';
    if (diffRatio < THRESHOLD_STATIC) {
      staticFrameCount++;
      if (staticFrameCount > 15) scene = 'static'; // 连续 15 帧静态
    } else {
      staticFrameCount = 0;
      if (diffRatio > THRESHOLD_HIGH_MOTION) scene = 'high_motion';
    }
    
    self.postMessage({ scene, diffRatio });
  }
  prevFrameData = currData;
  bitmap.close(); // 释放内存
};

async function applyEncodingStrategy(sender, scene) {
  const params = sender.getParameters();
  const encoding = params.encodings[0];
  if (!encoding) return;

  const strategies = {
    static: { scaleResolutionDownBy: 1.0, maxFramerate: 5, maxBitrate: 800_000 },
    interactive: { scaleResolutionDownBy: 1.0, maxFramerate: 15, maxBitrate: 1_500_000 },
    high_motion: { scaleResolutionDownBy: 1.5, maxFramerate: 30, maxBitrate: 4_000_000 }
  };
  
  Object.assign(encoding, strategies[scene]);
  await sender.setParameters(params); // 异步生效，无需重协商
}

// 使用示例
const videoTrack = stream.getVideoTracks()[0];
const sender = pc.getSenders().find(s => s.track?.kind === 'video');
const analyzer = new Worker('screen-share-analyzer.worker.js');

videoTrack.requestVideoFrameCallback(function callback(now, metadata) {
  analyzer.postMessage({ type: 'analyze', bitmap: metadata.frame }, [metadata.frame]);
  videoTrack.requestVideoFrameCallback(callback);
});

analyzer.onmessage = (e) => applyEncodingStrategy(sender, e.data.scene);

graph LR
    A[标签页音频<br/>getDisplayMedia audio:true] --> D[Web Audio Context<br/>DestinationNode]
    B[麦克风音频<br/>getUserMedia audio:true] --> D
    C[系统音频<br/>getDisplayMedia systemAudio:true] -.->|可选/慎用| D
    D --> E[GainNode 主音量控制]
    E --> F[AudioWorklet<br/>回声消除/降噪/AGC]
    F --> G[MediaStreamDestination]
    G --> H[RTCPeerConnection.addTrack]

// audio-processor.worklet.js
class AudioMixerProcessor extends AudioWorkletProcessor {
  constructor(options) {
    super();
    this.inputsConfig = options.processorOptions.inputsConfig; // [{name: 'tab', gain: 1}, {name: 'mic', gain: 0.8}]
    this.referenceBuffer = new Float32Array(128 * 50); // 50帧参考信号环形缓冲区 (用于AEC)
    this.refWriteIdx = 0;
    this.port.onmessage = (e) => {
      if (e.data.type === 'reference') this.setReferenceSignal(e.data.buffer);
      if (e.data.type === 'gain') this.updateGain(e.data.name, e.data.value);
    };
  }

  setReferenceSignal(float32Array) {
    // 远端音频作为 AEC 参考信号写入环形缓冲
    const len = float32Array.length;
    for (let i = 0; i < len; i++) {
      this.referenceBuffer[this.refWriteIdx++] = float32Array[i];
      if (this.refWriteIdx >= this.referenceBuffer.length) this.refWriteIdx = 0;
    }
  }

  process(inputs, outputs) {
    const output = outputs[0][0]; // 单声道输出
    const frameSize = output.length;
    output.fill(0);

    // 1. 混音各输入源
    inputs.forEach((inputChannels, idx) => {
      const input = inputChannels[0];
      if (!input) return;
      const gain = this.inputsConfig[idx]?.gain ?? 1.0;
      for (let i = 0; i < frameSize; i++) output[i] += input[i] * gain;
    });

    // 2. 简易 AEC (谱减法思想演示，生产建议集成 RNNoise/WebRTC APM 模块)
    // 此处仅作架构演示，实际 AEC 需频域自适应滤波器
    
    // 3. 能量计算用于静音检测
    let sumSq = 0;
    for (let i = 0; i < frameSize; i++) sumSq += output[i] * output[i];
    const rms = Math.sqrt(sumSq / frameSize);
    this.port.postMessage({ type: 'level', rms });

    return true;
  }
}
registerProcessor('audio-mixer', AudioMixerProcessor);

用户反馈“屏幕共享卡顿/模糊”
    │
    ├─▶ 查看 encode_frame_drop_rate > 2% ?
    │       ├─ 是 → 查看 CPU 占用 / 编码器类型 (硬编/软编)
    │       │       ├─ 软编 + 高分辨率 → 强制降分辨率 / 开启硬编
    │       │       └─ 硬编 + 旧驱动 → 建议更新显卡驱动 / 降级软编
    │       └─ 否 → 进入下一项
    │
    ├─▶ 查看 bitrate_actual_vs_target_ratio < 0.6 ?
    │       ├─ 是 → 查看 retransmit_rate / nack_count
    │       │       ├─ 高丢包 → 开启 FEC / 降低目标码率 / 开启 simulcast
    │       │       └─ 低丢包 → 检查带宽估计 (BWE) 是否收敛过慢
    │       └─ 否 → 进入下一项
    │
    └─▶ 查看 freeze_rate (接收端) > 1% ?
            ├─ 是 → 查看 jitter_buffer_delay
            │       ├─ 高抖动缓冲 → 网络抖动大，调整 `jitterBufferTarget` / 开启 RED
            │       └─ 正常 → 检查接收端解码器性能 / 主线程阻塞
            └─ 否 → 可能为主观感知差异，收集主观评分 (MOS) 校准阈值

// 业务侧调用示例
const screenShare = new ScreenShareManager({
  // 策略配置
  preferredResolution: '1080p',
  enableAudioCapture: true,        // 默认仅标签页音
  enableSystemAudio: false,        // 需用户二次确认
  antiSelfCapture: 'strict',       // 'strict' | 'loose' | 'none'
  adaptiveEncoding: true,          // 开启内容感知自适应
  
  // 可观测性
  telemetry: { sampleRate: 0.2, endpoint: '/api/rtc/metrics' },
  
  // 合规回调
  onComplianceCheck: (ctx) => showRecordingConsentDialog(ctx)
});

// 一行代码接入
const { stream, stop, switchSource } = await screenShare.start('#local-video');