// 方案1：针对React的完整事件模拟
async function simulateReactInput(element, text) {
    if (!element) return;
    
    // 1. 先聚焦
    element.focus();
    await sleep(50);
    
    // 2. 清空现有内容
    const descriptor = Object.getOwnPropertyDescriptor(element, 'value');
    if (descriptor && descriptor.set) {
        descriptor.set.call(element, '');
    }
    
    // 3. 触发React的onChange事件链
    ['focus', 'mousedown', 'mouseup', 'click'].forEach(eventName => {
        element.dispatchEvent(new MouseEvent(eventName, {
            bubbles: true,
            cancelable: true,
            view: window
        }));
    });
    
    // 4. 逐个字符输入（更真实的React方式）
    for (let i = 0; i < text.length; i++) {
        const char = text[i];
        
        // 设置值
        element.value += char;
        
        // React主要监听input事件，但要使用正确的属性
        const inputEvent = new InputEvent('input', {
            bubbles: true,
            cancelable: true,
            inputType: 'insertText',
            data: char,
            isComposing: false
        });
        
        // 触发input事件（React监听的）
        element.dispatchEvent(inputEvent);
        
        // 同时触发React的onChange事件
        const changeEvent = new Event('change', {
            bubbles: true,
            cancelable: true
        });
        element.dispatchEvent(changeEvent);
        
        // 触发键盘事件（可选）
        const keyDownEvent = new KeyboardEvent('keydown', {
            key: char,
            code: `Key${char.toUpperCase()}`,
            charCode: char.charCodeAt(0),
            keyCode: char.charCodeAt(0),
            which: char.charCodeAt(0),
            bubbles: true
        });
        element.dispatchEvent(keyDownEvent);
        
        await sleep(30 + Math.random() * 50);
    }
    
    // 5. 触发blur事件（React可能在这里进行验证）
    setTimeout(() => {
        element.blur();
        element.dispatchEvent(new Event('blur', { bubbles: true }));
    }, 100);
    
    return true;
}

let input = iframeDoc.querySelector('pre.edit[contenteditable="true"]')
      await sleep(300)
      await simulateHumanInputAwait(input, "你好")

async function simulateHumanInput(target, value, interval = 80) {
  target.focus()
  target.innerText = ""

  for (let i = 0; i < value.length; i++) {
    const char = value[i]
    target.innerText += char

    // 生成输入事件
    const inputEvent = new InputEvent("input", {
      bubbles: true,
      data: char,
      inputType: "insertText"
    })
    target.dispatchEvent(inputEvent)

    // 键盘事件
    const keyEventDown = new KeyboardEvent("keydown", {
      key: char,
      bubbles: true
    })
    const keyEventUp = new KeyboardEvent("keyup", { key: char, bubbles: true })
    target.dispatchEvent(keyEventDown)
    target.dispatchEvent(keyEventUp)

    await sleep(interval + Math.random() * 30)
  }

  target.blur()
}

(function () {
    const originalSend = XMLHttpRequest.prototype.send;
    const originalOpen = XMLHttpRequest.prototype.open;

    XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
        this._url = url;   // 保存请求 URL 以便后续使用
        this._method = method;
        this._async = async;
        originalOpen.apply(this, arguments);  // 保持原来的 open 方法
    };

    XMLHttpRequest.prototype.send = function (body) {
        const xhr = this;  // 保存当前 XMLHttpRequest 对象的引用

        console.log('拦截到 XHR 请求的响应：', xhr.responseText);
        // 拦截 onreadystatechange，获取响应数据
        xhr.addEventListener('readystatechange', function () {
            if (xhr.readyState === 4) {  // readyState 4 表示请求已完成
                console.log('拦截到 XHR 请求的响应：', xhr.responseText);

                // 在这里你可以对响应数据进行处理
                // alert(xhr.responseText)
                //拦截指定的url
                if (xhr._url.includes('keyword')) {
                    console.log(JSON.parse(xhr.responseText).data)
                }
            }
        });

        // 调用原始 send 方法
        originalSend.apply(this, arguments);
    };
})();

发送方

postMessage({type: 'NOTIFY', msg: 'msg'}, '*')  //

接收方

window.onmessage = (e) => {
  console.log("收到消息");
  let {  type , msg} = e.data;
  switch (type) {
    case "NOTIFY":

      break;
  }
};

let selects = document.getElementsByTagName("select");
  if (selects.length !== selectAnswer.length) {
    layer.msg("页面上的题可能已经发生了变化", { icon: 0 });
    return;
  }
  let lastScope = NaN;
  let idx = -1;
  // 获取Angular作用域
  selectAnswer.forEach((answer, index) => {
    let scope = angular.element(selects[index]).scope();
    // console.log(scope.subject.sub_subjects);
    // console.log(lastScope === scope, lastScope);
    if (idx === -1) {
      idx = 0;
    } else if (lastScope === scope) {
      idx += 1;
    } else {
      idx = 0;
    }
    lastScope = scope;

    //angular.element(document.getElementsByTagName("select")[0]).scope().subject.sub_subjects;
    scope.$apply(() => {
      console.log(scope.subject.sub_subjects[idx]);
      let old = scope.subject.sub_subjects[idx].answeredOption;
      scope.subject.sub_subjects[idx].answeredOption = answer;
      scope.onChangeSubmission(scope.subject.sub_subjects[idx]);

      console.log(scope.subject.sub_subjects[idx]);
      console.log(
        `old: ${old},new:${answer}, now:${scope.subject.sub_subjects[idx].answeredOption}`,
      );
    });
    $(selects[index]).multiselect("refresh");
    angular.element(selects[index]).triggerHandler("change");
  });