// 简化版请求流程
function Axios(config) {
  // 1. 合并配置
  this.defaults = mergeConfig(defaults, config);
  // 2. 初始化拦截器
  this.interceptors = {
    request: new InterceptorManager(),
    response: new InterceptorManager()
  };
}

Axios.prototype.request = function(config) {
  // 1. 参数处理（支持 axios('url', config) 形式）
  if (typeof config === 'string') {
    config = arguments[1] || {};
    config.url = arguments[0];
  }
  // 2. 合并配置
  config = mergeConfig(this.defaults, config);
  // 3. 转换请求数据
  config.data = transformData(
    config.data,
    config.headers,
    config.transformRequest
  );
  // 4. 构建请求链
  const chain = [dispatchRequest, undefined];
  // 5. 添加请求拦截器（后添加的先执行）
  this.interceptors.request.forEach(interceptor => {
    chain.unshift(interceptor.fulfilled, interceptor.rejected);
  });
  // 6. 添加响应拦截器（先添加的先执行）
  this.interceptors.response.forEach(interceptor => {
    chain.push(interceptor.fulfilled, interceptor.rejected);
  });
  // 7. 执行链
  let promise = Promise.resolve(config);
  while (chain.length) {
    promise = promise.then(chain.shift(), chain.shift());
  }
  return promise;
};

// 适配器选择逻辑
function getDefaultAdapter() {
  if (typeof XMLHttpRequest !== 'undefined') {
    // 浏览器环境使用 XHR 适配器
    return require('./adapters/xhr');
  } else if (typeof process !== 'undefined') {
    // Node.js 环境使用 http 适配器
    return require('./adapters/http');
  }
}

// 浏览器 XHR 适配器核心实现
module.exports = function xhrAdapter(config) {
  return new Promise((resolve, reject) => {
    const request = new XMLHttpRequest();
    // 初始化请求
    request.open(
      config.method.toUpperCase(),
      buildURL(config.url, config.params),
      true
    );
    // 设置超时
    request.timeout = config.timeout;
    // 设置响应类型
    if (config.responseType) {
      request.responseType = config.responseType;
    }
    // 设置请求头
    if (config.headers) {
      for (let key in config.headers) {
        request.setRequestHeader(key, config.headers[key]);
      }
    }
    // 处理取消
    if (config.cancelToken) {
      config.cancelToken.promise.then(reason => {
        request.abort();
        reject(reason);
      });
    }
    // 处理请求数据
    let requestData = config.data;
    if (requestData && !isStream(requestData)) {
      requestData = transformRequestData(requestData, config.headers);
    }
    // 请求完成处理
    request.onreadystatechange = function() {
      if (!request || request.readyState !== 4) return;
      const response = {
        data: transformResponseData(request.response, config),
        status: request.status,
        statusText: request.statusText,
        headers: parseHeaders(request.getAllResponseHeaders()),
        config: config,
        request: request
      };
      settle(resolve, reject, response);
      request = null;
    };
    // 错误处理
    request.onerror = function() {
      reject(createError('Network Error', config));
      request = null;
    };
    // 超时处理
    request.ontimeout = function() {
      reject(createError(`timeout of ${config.timeout}ms exceeded`, config));
      request = null;
    };
    // 发送请求
    request.send(requestData);
  });
};

function InterceptorManager() {
  this.handlers = [];
}
InterceptorManager.prototype.use = function(fulfilled, rejected) {
  this.handlers.push({ fulfilled, rejected });
  return this.handlers.length - 1;
};
InterceptorManager.prototype.eject = function(id) {
  if (this.handlers[id]) {
    this.handlers[id] = null;
  }
};
// 请求链构建逻辑
const chain = [dispatchRequest, undefined];
this.interceptors.request.forEach(interceptor => {
  chain.unshift(interceptor.fulfilled, interceptor.rejected);
});
this.interceptors.response.forEach(interceptor => {
  chain.push(interceptor.fulfilled, interceptor.rejected);
});

// 适配 AbortController
if (config.cancelToken) {
  config.cancelToken.promise.then(reason => {
    request.abort();
    reject(reason);
  });
}
if (config.signal) {
  config.signal.aborted || config.signal.addEventListener('abort', () => {
    request.abort();
    reject(new Cancel('canceled'));
  });
}

// 默认转换函数
transformRequest: [
  function(data, headers) {
    // 处理 Content-Type
    if (isFormData(data) || isArrayBuffer(data) || isStream(data)) {
      return data;
    }
    if (isArrayBufferView(data)) {
      return data.buffer;
    }
    if (isURLSearchParams(data)) {
      setContentType(headers, 'application/x-www-form-urlencoded');
      return data.toString();
    }
    if (isObject(data)) {
      setContentType(headers, 'application/json');
      return JSON.stringify(data);
    }
    return data;
  }
],
transformResponse: [
  function(data) {
    if (typeof data === 'string') {
      try {
        data = JSON.parse(data);
      } catch (e) {}
    }
    return data;
  }
]

// postcss.config.js
module.exports = {
  plugins: {
    'postcss-write-svg': {
      utf8: false
    }
  }
}

document.addEventListener('touchstart', function(event) {
  if (event.touches.length > 1) {
    event.preventDefault(); // 阻止双指缩放
  }
}, { passive: false });

let lastTouchEnd = 0;
document.addEventListener('touchend', function(event) {
  const now = Date.now();
  if (now - lastTouchEnd <= 300) {
    event.preventDefault(); // 阻止双击缩放
  }
  lastTouchEnd = now;
}, { passive: false });

document.addEventListener('gesturestart', function(e) {
  e.preventDefault(); // 阻止Android手势缩放
});

const modal = document.querySelector('.modal');
modal.addEventListener('touchmove', (e) => {
  e.preventDefault(); // 阻止默认滚动
}, { passive: false }); // 必须设置 passive: false

let startY = 0;
modal.addEventListener('touchstart', (e) => {
  startY = e.touches[0].clientY;
}, { passive: true });

modal.addEventListener('touchmove', (e) => {
  const currentY = e.touches[0].clientY;
  const scrollTop = modal.scrollTop;
  const isTop = (scrollTop <= 0 && currentY > startY); // 向下滑到顶部
  const isBottom = (scrollTop + modal.offsetHeight >= modal.scrollHeight && currentY < startY); // 向上滑到底部

  if (isTop || isBottom) {
    e.preventDefault(); // 阻止边界穿透
  }
}, { passive: false });

let scrollTop = 0;
function openModal() {
  scrollTop = window.scrollY;
  document.body.style.position = 'fixed';
  document.body.style.top = `-${scrollTop}px`;
}
function closeModal() {
  document.body.style.position = '';
  window.scrollTo(0, scrollTop);
}

// React示例
useEffect(() => {
  const body = document.body;
  const originalStyle = window.getComputedStyle(body).overflow;
  body.style.overflow = 'hidden';
  return () => { body.style.overflow = originalStyle; };
}, []);

function focusInput(inputElement) {
  inputElement.addEventListener('focus', () => {
    setTimeout(() => {
      // 滚动到输入框位置（兼容iOS/Android）
      inputElement.scrollIntoView({ 
        behavior: 'smooth', 
        block: 'center' // 或 'start'/'end'
      });
    }, 300); // 延迟确保键盘已弹出
  });
}
// 对所有输入框生效
document.querySelectorAll('input, textarea').forEach(focusInput);

// JS：检测键盘状态
const inputs = document.querySelectorAll('input, textarea');
inputs.forEach(input => {
  input.addEventListener('focus', () => {
    document.body.classList.add('keyboard-active');
    window.scrollTo(0, document.body.scrollHeight);
  });
  input.addEventListener('blur', () => {
    document.body.classList.remove('keyboard-active');
  });
});

// 修复iOS键盘收起后页面空白
function fixIOSKeyboard() {
  if (/iPhone|iPad|iPod/i.test(navigator.userAgent)) {
    document.addEventListener('focusout', () => {
      setTimeout(() => {
        window.scrollTo(0, Math.max(document.body.scrollHeight - window.innerHeight, 0));
      }, 100);
    });
  }
}
fixIOSKeyboard();

// 计算可见项起始索引
const startIndex = Math.floor(scrollTop / itemHeight)
// 计算可见项结束索引
const endIndex = Math.min(
  startIndex + Math.ceil(viewportHeight / itemHeight),
  totalItems - 1
)
// 计算内容容器偏移量
const offset = startIndex * itemHeight

// Android调用方式
prompt(JSON.stringify(msgJson));  // 通过prompt协议通信
// iOS调用方式
iframe.src = 'kcnative://go';     // 通过URL Scheme触发

kerkee.initData(function(res) {
  console.log('获取到的token:', res.key); 
});
// 实际调用链路：
ApiBridge.callNative('jsBridgeClient', 'initData', {}, callback)
↓
// Android端：
prompt('{"clz":"jsBridgeClient","method":"initData","args":{}}')
↓
// iOS端：
iframe.src = 'kcnative://go?msg=' + encodeURIComponent(JSON.stringify(msg))

// 原生调用H5注册的回调
ApiBridge.onCallback(callbackId, responseData);
↓
// 触发H5预先注册的回调函数
callbackCache[callbackId](responseData);

var ApiBridge = {
  msgQueue: [],       // 待发送消息队列
  callbackCache: [],  // 回调函数缓存
  callbackId: 0,      // 自增ID保证唯一性

  callNative: function(clz, method, args, callback) {
    const msg = { clz, method, args };
    if(callback) {
      const callbackId = this.callbackId++;
      this.callbackCache[callbackId] = callback;
      msg.args.callbackId = callbackId;
    }
    this.msgQueue.push(msg);
    this.flushMessages(); // 触发消息发送
  }
}

import { _base64ToArrayBuffer } from 'UTILS/utils'
import pushOtions from 'UTILS/pushOtions'
import { decode } from 'UTILS/Axios'

/**
 * 客户端通信交互
 */
; (function (window) {
  // 避免多次初始化
  if (window.WebViewJSBridge) return
  window.WebViewJSBridge = {}

  var browser = {
    versions: (function () {
      var u = navigator.userAgent
      const agents = [
        'miya',
      ]

      let result = agents.some(item => u.indexOf(item) != -1)

      return {
        isLocal: /(localhost|10\.|0\.0|192\.168)/.test(location.origin),
        inApp: result ? 1 : 0,
        trident: u.indexOf('Trident') > -1, //IE
        presto: u.indexOf('Presto') > -1, //opera
        webKit: u.indexOf('AppleWebKit') > -1, //apple&google kernel
        gecko: u.indexOf('Gecko') > -1 && u.indexOf('KHTML') == -1, //firfox
        mobile: !!u.match(/AppleWebKit.*Mobile.*/), //is Mobile
        ios:
          !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/i) ||
          !!u.match(/\(Maci[^;]+; .+Mac OS X/i), //is ios
        android: u.indexOf('Android') > -1 || u.indexOf('Adr') > -1, //android
        iPhone: u.indexOf('iPhone') > -1, //iPhone or QQHD
        iPad: u.indexOf('iPad') > -1, //iPad
        iPod: u.indexOf('iPod') > -1, //iPod
        webApp: u.indexOf('Safari') == -1, //is webapp,no header and footer
        weixin: u.indexOf('MicroMessenger') > -1, //is wechat
        qq: u.match(/\sQQ/i) == ' qq', //is qq
        PCMiz: /PCMiz/i.test(u) // mizpc
      }
    })(),
    language: (
      navigator.browserLanguage || navigator.language
    ).toLowerCase()
  }

  function getQueryString(name, isUrl) {
    var reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i')
    var r = window.location.search.substr(1).match(reg)
    if (r != null) return isUrl ? decodeURIComponent(r[2]) : unescape(r[2])
    return null
  }

  var global = this || window
  var ApiBridge = {
    msgQueue: [],
    callbackCache: [],
    callbackId: 0,
    processingMsg: false,
    isReady: false,
    isNotifyReady: false
  }

  ApiBridge.create = function () {
    ApiBridge.bridgeIframe = document.createElement('iframe')
    ApiBridge.bridgeIframe.style.display = 'none'
    document.documentElement.appendChild(ApiBridge.bridgeIframe)
  }

  ApiBridge.prepareProcessingMessages = function () {
    ApiBridge.processingMsg = true
  }

  ApiBridge.fetchMessages = function () {
    if (ApiBridge.msgQueue.length > 0) {
      var messages = JSON.stringify(ApiBridge.msgQueue)
      ApiBridge.msgQueue.length = 0
      return messages
    }
    ApiBridge.processingMsg = false
    return null
  }

  ApiBridge.callNative = function (clz, method, args, callback) {
    var msgJson = {}
    msgJson.clz = clz
    msgJson.method = method
    if (args != undefined) msgJson.args = args
    if (callback) {
      var callbackId = ApiBridge.getCallbackId()
      ApiBridge.callbackCache[callbackId] = callback
      if (msgJson.args) {
        msgJson.args.callbackId = callbackId.toString()
      } else {
        msgJson.args = {
          callbackId: callbackId.toString()
        }
      }
    }

    if (
      browser.versions.inApp ||
      window.isInApp ||
      (!browser.versions.weixin &&
        !browser.versions.qq &&
        getQueryString('id') !== null &&
        !/.*#\/share?/gi.test(location.href))
    ) {
      if (browser.versions.ios) {
        if (ApiBridge.bridgeIframe == undefined) {
          ApiBridge.create()
        }
        ApiBridge.msgQueue.push(msgJson)
        if (!ApiBridge.processingMsg)
          ApiBridge.bridgeIframe.src = 'kcnative://go'
      } else if (browser.versions.android) {
        // 兼容马甲包
        const agents = ['miya', 'myyw', 'buou', 'ppyy', 'ppkh'],
          ua = window.navigator.userAgent

        let result = agents.some(item => ua.indexOf(item) > -1)

        // 添加判断，是app可进行跳转。浏览器则不显示弹窗
        result && prompt(JSON.stringify(msgJson))
        // browser.versions.inApp && prompt(JSON.stringify(msgJson));
        // android
        // prompt(JSON.stringify(msgJson));
        // prompt("弹窗")
      }
    }
  }

  ApiBridge.getCallbackId = function () {
    return ApiBridge.callbackId++
  }

  ApiBridge.onCallback = function (callbackId, obj) {
    if (ApiBridge.callbackCache[callbackId]) {
      ApiBridge.callbackCache[callbackId](obj)
    }
  }

  ApiBridge.onBridgeInitComplete = function (callback) {
    ApiBridge.callNative(
      'ApiBridge',
      'onBridgeInitComplete',
      {},
      callback
    )
  }

  ApiBridge.onNativeInitComplete = function (callback) {
    ApiBridge.isReady = true
    if (callback) {
      callback()
      ApiBridge.isNotifyReady = true
    }
  }

  ApiBridge.compile = function (aIdentity, aJS) {
    var value
    var error
    try {
      value = eval(aJS)
    } catch (e) {
      var err = {}
      err.name = e.name
      err.message = e.message
      err.number = e.number & 0xffff
      error = err
    }

    ApiBridge.callNative('ApiBridge', 'compile', {
      identity: aIdentity,
      returnValue: value,
      error: error
    })
  }

  var _Configs = {
    isOpenJSLog: false,
    sysLog: {},
    isOpenNativeXHR: true,
    sysXHR: {}
  }
  _Configs.sysLog = global.console.log
  _Configs.sysXHR = global.XMLHttpRequest

  // js通信交互方法
  var kerkee = {}

  /*****************************************
   * 事件监听
   *****************************************/
  kerkee.Event = {}
  kerkee.addEventListener = function (event, callback) {
    ApiBridge.callNative(
      'event',
      'addEventListener',
      {
        event: event
      },
      callback
    )
  }

  kerkee.registerHitPageBottomListener = function (callback, threshold) {
    ApiBridge.callNative('ApiBridge', 'setHitPageBottomThreshold', {
      threshold: threshold
    })
    kerkee.onHitPageBottom = callback
  }

  /**
   * 设备已准备完成
   */
  kerkee.onDeviceReady = function (handler) {
    ApiBridge.onDeviceReady = handler

    if (ApiBridge.isReady && !ApiBridge.isNotifyReady && handler) {
      console.log('-- device ready --')
      handler()
      ApiBridge.isNotifyReady = true
    }
  }

  /*****************************************
   * 接口
   *****************************************/
  /**
   * 获取客户端用户token
   * @params { Function }, callback 回调
   * @return { Object } ,  { key, player }
   *
   */
  kerkee.initData = function (callback) {
    ApiBridge.callNative('jsBridgeClient', 'initData', {}, callback)
  }

  global.ApiBridge = ApiBridge
  global.kerkee = kerkee
  global.jsBridgeClient = kerkee

  // 注册事件，绑定到全局方法
  kerkee.register = function (_window) {
    _window.ApiBridge = window.ApiBridge
    _window.kerkee = window.kerkee
    _window.console.log = window.console.log
    _window.XMLHttpRequest = window.XMLHttpRequest
    _window.open = window.open
  }

  // 客户端配置 TODO
  ApiBridge.onBridgeInitComplete(function (aConfigs) {
    if (aConfigs) {
      if (aConfigs.hasOwnProperty('isOpenNativeXHR')) {
        _Configs.isOpenNativeXHR = aConfigs.isOpenNativeXHR
      }
    }
    ApiBridge.onNativeInitComplete(ApiBridge.onDeviceReady)
  })

  /**
   * h5注册监听服务端⼴播
   * @params { Obejct }, optinos 配置项
   * @params { Function }, callback 回调
   * @return { Object }
   *
   */
  kerkee.subscribeAppPush = function (cmdId, callback) {
    if (!window.onAppPush) {
      window.onAppPush = function (resCmdId, data) {
        // 客户端返回base64转字节数组
        const arrayBuffer = _base64ToArrayBuffer(data)

        const index = pushOtions.findIndex(
          item => item.cmdId === resCmdId
        )
        let resData = null
        if (index > -1) {
          resData = decode(
            pushOtions[index].resDesction,
            new Uint8Array(arrayBuffer)
          )
        } else {
          resData = '无法解析数据'
        }

        callback(resCmdId, resData)
      }
    }

    ApiBridge.callNative('jsBridgeClient', 'subscribeAppPush', {
      cmdId: cmdId
    })
  }
})(window)

// SCHEMA_PATH 为 URL Scheme 地址

// location.href 形式
window.top.location.href = SCHEMA_PATH;

// a标签形式
const a = document.createElement("a");
a.setAttribute("href", SCHEMA_PATH);
a.click();

// iframe形式
iframe = document.createElement('iframe');
iframe.frameBorder = '0';
iframe.style.cssText = 'display:none;border:0;width:0;height:0;';
document.body.append(iframe);
iframe.src = SCHEMA_PATH;

// n秒后执行下载
const timer = setTimeout(() => {
  this.__download(options);
}, options.delay);

// 页面隐藏，那么代表已经调起了app，就清除下载的定时器
const visibilitychange = function() {
  const tag = document.hidden || document.webkitHidden;
  tag && clearTimeout(timer);
};

document.addEventListener("visibilitychange", visibilitychange, false);
document.addEventListener("webkitvisibilitychange", visibilitychange, false);
window.addEventListener(
  "pagehide",
  function() {
    clearTimeout(timer);
  },
  false
);

// Web Worker代码 (compute.js)
// 模拟长时间计算
function heavyCompute() {
  const start = Date.now();
  let progress = 0;
  // 模拟5秒计算
  while (progress < 100) {
    // 每100ms更新一次进度
    if (Date.now() - start > progress * 50) {
      progress++;
      // 向主线程发送进度更新
      self.postMessage({ type: 'progress', value: progress });
    }
  }
  return "计算完成";
}
// 监听主线程消息
self.onmessage = (e) => {
  if (e.data === 'start') {
    const result = heavyCompute();
    self.postMessage({ type: 'result', value: result });
  }
};

// 使用 sendBeacon
if (navigator.sendBeacon) {
  const blob = new Blob([JSON.stringify(data)], { type: 'application/json' });
  navigator.sendBeacon('/api/page-exit', blob);
}

// 这个也能发送
fetch('/api/save', {
  method: 'POST',
  body: JSON.stringify(data),
  keepalive: true,  // ✅ 关键参数
  headers: { 'Content-Type': 'application/json' }
});

// 图片请求（最可靠）
function sendImageRequest(data) {
  const params = new URLSearchParams();
  params.append('exit_data', btoa(JSON.stringify(data)));
  params.append('_', Date.now());
  
  new Image().src = `/api/track.gif?${params}`;
}

// 用户离开页面时发送（切换标签、最小化、关闭等）
document.addEventListener('visibilitychange', () => {
  if (document.visibilityState === 'hidden') {
    // 页面不可见时发送数据
    sendHiddenData();
  }
});

// 也监听 beforeunload 作为最后机会
window.addEventListener('beforeunload', () => {
  sendHiddenData();
});

function sendHiddenData() {
  const data = {
    type: 'page_hidden',
    timestamp: Date.now(),
    url: window.location.href,
    duration: calculatePageDuration(),
    // 你的业务数据
  };
  
  // 使用 sendBeacon
  if (navigator.sendBeacon) {
    const blob = new Blob([JSON.stringify(data)], { type: 'application/json' });
    navigator.sendBeacon('/api/page-exit', blob);
  } else {
    // 回退方案
    sendSyncRequest(data);
  }
}

function calculatePageDuration() {
  if (!window.pageEnterTime) {
    window.pageEnterTime = Date.now();
  }
  return Date.now() - window.pageEnterTime;
}

// 按需引入
import { Button } from 'vant-weapp';