// addon-first native-like 保护工具。
// 1) 创建函数、getter、setter、document.all、构造函数、原型链、集合对象和插件列表时，优先尝试 addon API。
// 2) addon.node 缺失、ABI 不兼容或调用失败时，才降级到 NativeProtect / JS fallback。
// 3) 本模块自动尝试加载随 Skill 携带的 addon.node，并记录 usedApis / fallbacks，便于写入 notes 和最终总结。
// 注意：复制到 case/result 时不要写死本机绝对路径，优先使用相对 assets/native-addon 或 WEB_JS_ENV_PATCHER_ADDON。

'use strict';

let fs = null;
let path = null;
try { fs = require('fs'); path = require('path'); } catch {}

class NativeProtect {
  #map = new Map();
  #objMap = new Map();
  static #instance = null;

  static getInstance() {
    if (!NativeProtect.#instance) {
      NativeProtect.#instance = new NativeProtect();
      const rawFunctionToString = Function.prototype.toString;
      const patchedFunctionToString = {
        toString() {
          if (NativeProtect.#instance.#map.has(this)) {
            const name = NativeProtect.#instance.#map.get(this);
            return `function ${name || this.name}() { [native code] }`;
          }
          return rawFunctionToString.call(this);
        }
      }.toString;
      Object.defineProperty(Function.prototype, 'toString', {
        value: patchedFunctionToString,
        writable: true,
        enumerable: false,
        configurable: true,
      });
      NativeProtect.#instance.#map.set(Function.prototype.toString, 'toString');

      const rawObjectToString = Object.prototype.toString;
      const patchedObjectToString = {
        toString() {
          if (NativeProtect.#instance.#objMap.has(this)) {
            const name = NativeProtect.#instance.#objMap.get(this);
            return `[object ${name}]`;
          }
          return rawObjectToString.call(this);
        }
      }.toString;
      Object.defineProperty(Object.prototype, 'toString', {
        value: patchedObjectToString,
        writable: true,
        enumerable: false,
        configurable: true,
      });
      NativeProtect.#instance.#map.set(Object.prototype.toString, 'toString');
    }
    return NativeProtect.#instance;
  }

  constructor() {
    if (NativeProtect.#instance) throw new Error('NativeProtect 类只能实例化一次');
  }

  setNativeFunc(func, name = '') { this.#map.set(func, name); }
  setObjFunc(obj, name = '') { this.#objMap.set(obj, name); }
}

function getNativeProtect() {
  return NativeProtect.getInstance();
}

function markNativeFunction(func, name = '') {
  if (typeof func === 'function') getNativeProtect().setNativeFunc(func, name || func.name || '');
  return func;
}

function markObjectToString(obj, tag = '') {
  if (!obj || !tag) return obj;
  try {
    Object.defineProperty(obj, Symbol.toStringTag, {
      value: tag,
      writable: false,
      enumerable: false,
      configurable: true,
    });
  } catch {}
  getNativeProtect().setObjFunc(obj, tag);
  return obj;
}

const nativeAddonUsage = {
  available: false,
  path: '',
  autoLoadAttempted: false,
  usedApis: [],
  fallbacks: [],
  attempts: [],
};

let cachedNativeAddon = null;
let nativeAddonResolved = false;
const privateStore = new WeakMap();

function addCandidate(out, p) {
  if (!p || !path) return;
  try { out.push(path.resolve(p)); } catch { out.push(String(p)); }
}

function addAddonFileCandidates(out, base, platformArch) {
  if (!base) return;
  if (platformArch) {
    addCandidate(out, path.join(base, platformArch, 'addon.node'));
    addCandidate(out, path.join(base, platformArch, `addon-${platformArch}.node`));
  }
  addCandidate(out, path.join(base, 'addon.node'));
}

function nativeAddonCandidates(extra) {
  const out = [];
  if (Array.isArray(extra)) for (const p of extra) addCandidate(out, p);
  else if (extra) addCandidate(out, extra);

  const hasProcess = typeof process !== 'undefined' && process && process.versions;
  const platformArch = hasProcess ? `${process.platform}-${process.arch}` : '';
  if (hasProcess && process.env && process.env.WEB_JS_ENV_PATCHER_ADDON) addCandidate(out, process.env.WEB_JS_ENV_PATCHER_ADDON);

  if (path && hasProcess && process.cwd) {
    addAddonFileCandidates(out, path.join(process.cwd(), 'assets', 'native-addon'), platformArch);
    addAddonFileCandidates(out, path.join(process.cwd(), 'native-addon'), platformArch);
  }

  if (path && typeof __dirname !== 'undefined') {
    const bases = [
      path.join(__dirname, 'native-addon'),
      path.join(__dirname, 'assets', 'native-addon'),
      path.join(__dirname, '..', 'native-addon'),
      path.join(__dirname, '..', 'assets', 'native-addon'),
      path.join(__dirname, '..', '..', 'native-addon'),
      path.join(__dirname, '..', '..', 'assets', 'native-addon'),
      path.join(__dirname, '..', '..', '..', 'native-addon'),
      path.join(__dirname, '..', '..', '..', 'assets', 'native-addon'),
    ];
    for (const base of bases) addAddonFileCandidates(out, base, platformArch);
  }

  return [...new Set(out)];
}

function tryRequireAddon(p) {
  try {
    if (fs && !fs.existsSync(p)) {
      nativeAddonUsage.attempts.push({ path: p, ok: false, reason: '文件不存在' });
      return null;
    }
    const addon = require(p);
    nativeAddonUsage.available = true;
    nativeAddonUsage.path = p;
    nativeAddonUsage.attempts.push({ path: p, ok: true, reason: '' });
    return addon;
  } catch (err) {
    nativeAddonUsage.attempts.push({ path: p, ok: false, reason: err && err.message ? err.message : String(err) });
    return null;
  }
}

function loadNativeAddon(options = {}) {
  const hasExplicit = !!(options.addon || options.path || options.candidates);
  if (nativeAddonResolved && !options.force && !hasExplicit) return cachedNativeAddon;
  nativeAddonUsage.autoLoadAttempted = true;
  for (const p of nativeAddonCandidates(options.addon || options.path || options.candidates)) {
    const addon = tryRequireAddon(p);
    if (addon) {
      cachedNativeAddon = addon;
      nativeAddonResolved = true;
      return addon;
    }
  }
  if (!hasExplicit || !cachedNativeAddon) nativeAddonResolved = true;
  return cachedNativeAddon;
}

function normalizeAddon(addonLike, allowAutoLoad = true) {
  if (addonLike && typeof addonLike === 'object' && Object.prototype.hasOwnProperty.call(addonLike, 'available') && addonLike.available === false) return null;
  if (addonLike && typeof addonLike === 'object' && Object.prototype.hasOwnProperty.call(addonLike, 'addon')) return normalizeAddon(addonLike.addon, false);
  if (addonLike && (typeof addonLike === 'object' || typeof addonLike === 'function')) return addonLike;
  if (allowAutoLoad) return cachedNativeAddon || loadNativeAddon();
  return null;
}

function setNativeAddon(addonLike) {
  const addon = normalizeAddon(addonLike, false);
  cachedNativeAddon = addon;
  nativeAddonResolved = true;
  nativeAddonUsage.available = !!addon;
  nativeAddonUsage.path = addonLike && addonLike.path || nativeAddonUsage.path || '';
  if (addonLike && Array.isArray(addonLike.attempts)) nativeAddonUsage.attempts.push(...addonLike.attempts);
  return addon;
}

function getNativeAddon() {
  return normalizeAddon(null, true);
}

function getAddonApi(addonLike, apiName) {
  const addon = normalizeAddon(addonLike, true);
  if (addon && typeof addon[apiName] === 'function') {
    nativeAddonUsage.available = true;
    return addon[apiName].bind(addon);
  }
  return null;
}

function isAddonLike(value) {
  return !!(
    value &&
    (typeof value === 'object' || typeof value === 'function') &&
    (
      typeof value.createNativeFunction === 'function' ||
      typeof value.createProtoChains === 'function' ||
      typeof value.getMimeTypesAndPlugins === 'function' ||
      Object.prototype.hasOwnProperty.call(value, 'addon')
    )
  );
}

function recordAddonUse(apiName) {
  if (!nativeAddonUsage.usedApis.includes(apiName)) nativeAddonUsage.usedApis.push(apiName);
}

function recordAddonFallback(apiName, reason) {
  nativeAddonUsage.fallbacks.push({ api: apiName, reason: reason || 'addon 不可用，使用 JS fallback' });
}

function getNativeAddonUsage() {
  return {
    available: nativeAddonUsage.available,
    path: nativeAddonUsage.path,
    autoLoadAttempted: nativeAddonUsage.autoLoadAttempted,
    usedApis: nativeAddonUsage.usedApis.slice(),
    fallbacks: nativeAddonUsage.fallbacks.slice(),
    attempts: nativeAddonUsage.attempts.slice(),
  };
}

function defineValue(obj, key, value, options = {}) {
  Object.defineProperty(obj, key, {
    value,
    writable: options.writable ?? false,
    enumerable: options.enumerable ?? true,
    configurable: options.configurable ?? true,
  });
  return value;
}

function defineGetter(obj, key, getter, options = {}) {
  Object.defineProperty(obj, key, {
    get: getter,
    enumerable: options.enumerable ?? true,
    configurable: options.configurable ?? true,
  });
  return getter;
}

function defineSetter(obj, key, setter, options = {}) {
  Object.defineProperty(obj, key, {
    set: setter,
    enumerable: options.enumerable ?? true,
    configurable: options.configurable ?? true,
  });
  return setter;
}

function setFunctionMeta(fn, name, length) {
  try { if (name) Object.defineProperty(fn, 'name', { value: name, configurable: true }); } catch {}
  try { if (Number.isFinite(length)) Object.defineProperty(fn, 'length', { value: length, configurable: true }); } catch {}
  return fn;
}

function createNativeFunction(name, length, impl, addon) {
  const api = getAddonApi(addon, 'createNativeFunction');
  if (api) {
    try {
      const fn = api(false, name, length ?? impl.length ?? 0, impl);
      recordAddonUse('createNativeFunction');
      return fn;
    } catch (err) {
      recordAddonFallback('createNativeFunction', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createNativeFunction', 'addon 不可用，使用 NativeProtect fallback');
  }
  return markNativeFunction(setFunctionMeta(impl, name, length ?? impl.length ?? 0), name);
}

function createNativeConstructor(name, length, impl, addon) {
  const api = getAddonApi(addon, 'createNativeFunction');
  if (api) {
    try {
      const ctor = api(true, name, length ?? 0, impl);
      recordAddonUse('createNativeFunction');
      return ctor;
    } catch (err) {
      recordAddonFallback('createNativeFunction', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createNativeFunction', 'addon 不可用，构造函数使用 NativeProtect fallback');
  }
  const ctor = function (...args) {
    return impl.call(this, new.target ? true : false, ...args);
  };
  return markNativeFunction(setFunctionMeta(ctor, name, length ?? 0), name);
}

function createNativeGetter(name, impl, addon) {
  const api = getAddonApi(addon, 'createGetter');
  if (api) {
    try {
      const getter = api(name, 0, impl);
      recordAddonUse('createGetter');
      return getter;
    } catch (err) {
      recordAddonFallback('createGetter', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createGetter', 'addon 不可用，getter 使用 NativeProtect fallback');
  }
  return markNativeFunction(setFunctionMeta(impl, `get ${name}`, 0), `get ${name}`);
}

function createNativeSetter(name, impl, addon) {
  const api = getAddonApi(addon, 'createSetter');
  if (api) {
    try {
      const setter = api(name, 1, impl);
      recordAddonUse('createSetter');
      return setter;
    } catch (err) {
      recordAddonFallback('createSetter', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createSetter', 'addon 不可用，setter 使用 NativeProtect fallback');
  }
  return markNativeFunction(setFunctionMeta(impl, `set ${name}`, 1), `set ${name}`);
}

const UNDETECTABLE_HANDLER_NAMES = new Set(['getter', 'setter', 'query', 'deleter', 'enumerator', 'definer', 'descriptor']);

function splitAddonAndHandlers(second, third) {
  let addon = null;
  let handlers = null;
  if (second && typeof second === 'object' && (second.addon || second.handlers)) {
    addon = second.addon || null;
    handlers = second.handlers || third || null;
  } else if (second && typeof second === 'object' && [...UNDETECTABLE_HANDLER_NAMES].some(k => typeof second[k] === 'function')) {
    handlers = second;
    addon = third || null;
  } else if (second && typeof second === 'object' && isAddonLike(third)) {
    handlers = second;
    addon = third;
  } else {
    addon = second || null;
    handlers = third || null;
  }
  return { addon, handlers };
}

function createUndetectable(impl, addonOrHandlers, maybeHandlers) {
  const { addon, handlers } = splitAddonAndHandlers(addonOrHandlers, maybeHandlers);
  const api = getAddonApi(addon, 'createUndetectable');
  if (api) {
    try {
      const value = handlers ? api(impl, handlers) : api(impl);
      recordAddonUse('createUndetectable');
      return value;
    } catch (err) {
      recordAddonFallback('createUndetectable', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createUndetectable', 'addon 不可用，document.all 只能使用近似 fallback');
  }
  return undefined;
}

function createInterceptor(options = {}, addon) {
  const api = getAddonApi(addon || options.addon, 'createInterceptor');
  if (api) {
    try {
      const value = api(options);
      recordAddonUse('createInterceptor');
      return value;
    } catch (err) {
      recordAddonFallback('createInterceptor', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createInterceptor', 'addon 不可用，使用 Proxy 近似 fallback');
  }

  const target = options.target && typeof options.target === 'object' ? options.target : {};
  const handlers = options.handlers || {};
  const proxy = new Proxy(target, {
    get(obj, property, receiver) {
      if (typeof handlers.getter === 'function') {
        const got = handlers.getter(obj, property);
        if (!got || got.intercept !== false) return got && Object.prototype.hasOwnProperty.call(got, 'value') ? got.value : got;
      }
      return Reflect.get(obj, property, receiver);
    },
    set(obj, property, value, receiver) {
      if (typeof handlers.setter === 'function') {
        const got = handlers.setter(obj, property, value);
        if (got && got.intercept === true) return Reflect.set(obj, property, got.value, receiver);
        if (got && got.intercept === false) return Reflect.set(obj, property, value, receiver);
      }
      return Reflect.set(obj, property, value, receiver);
    },
    getOwnPropertyDescriptor(obj, property) {
      if (typeof handlers.descriptor === 'function') {
        const desc = handlers.descriptor(obj, property);
        if (desc) return desc;
      }
      return Reflect.getOwnPropertyDescriptor(obj, property);
    },
    ownKeys(obj) {
      if (typeof handlers.enumerator === 'function') {
        const keys = handlers.enumerator(obj);
        if (Array.isArray(keys)) return keys;
      }
      return Reflect.ownKeys(obj);
    },
    deleteProperty(obj, property) {
      if (typeof handlers.deleter === 'function') return !!handlers.deleter(obj, property);
      return Reflect.deleteProperty(obj, property);
    },
    defineProperty(obj, property, descriptor) {
      if (typeof handlers.definer === 'function') {
        const got = handlers.definer(obj, property, descriptor);
        if (got === false || (got && got.intercept === false)) return false;
      }
      return Reflect.defineProperty(obj, property, descriptor);
    },
  });
  if (options.internalClassName) markObjectToString(proxy, options.internalClassName);
  return proxy;
}

function isDescriptorObject(value) {
  return value && typeof value === 'object' && ('value' in value || 'get' in value || 'set' in value);
}

function createNativeObjectFallback(tag, proto, properties = {}) {
  const obj = Object.create(proto || Object.prototype);
  for (const [key, desc] of Object.entries(properties || {})) {
    try {
      Object.defineProperty(obj, key, isDescriptorObject(desc) ? desc : {
        value: desc,
        writable: true,
        enumerable: true,
        configurable: true,
      });
    } catch {}
  }
  if (tag) markObjectToString(obj, tag);
  return obj;
}

function createNativeObjectFromOptionsFallback(options = {}) {
  const name = options.name || 'NativeObject';
  const ctor = createNativeConstructor(name, options.length ?? 0, options.constructor || function () {}, null);
  if (options.parent && typeof options.parent === 'object') {
    const parent = createNativeObjectFromOptionsFallback(options.parent);
    try { Object.setPrototypeOf(ctor.prototype, parent.constructor.prototype); } catch {}
    try { Object.setPrototypeOf(ctor, parent.constructor); } catch {}
  }
  if (options.isReadOnlyPrototype) {
    try { Object.defineProperty(ctor, 'prototype', { writable: false }); } catch {}
  }
  if (options.isImmutableProto) {
    try { Object.preventExtensions(ctor.prototype); } catch {}
  }
  const instance = Object.create(ctor.prototype);
  if (typeof options.constructor === 'function') {
    try { options.constructor.call(instance, false); } catch {}
  }
  if (options.isImmutableInstanceProto) {
    try { Object.preventExtensions(instance); } catch {}
  }
  markObjectToString(instance, name);
  return { instance, constructor: ctor, prototypeChains: [] };
}

function createNativeObject(arg1, arg2, arg3, arg4) {
  const isOptions = arg1 && typeof arg1 === 'object' && !Array.isArray(arg1) && typeof arg1.name === 'string';
  const addon = isOptions ? arg2 : arg4;
  const api = getAddonApi(addon, 'createNativeObject');

  if (isOptions && api) {
    try {
      const result = api(arg1);
      recordAddonUse('createNativeObject');
      return result;
    } catch (err) {
      recordAddonFallback('createNativeObject', err && err.message ? err.message : String(err));
    }
  } else if (!isOptions) {
    recordAddonFallback('createNativeObject', '检测到旧式 createNativeObject(tag, proto, properties) 调用，新代码应迁移为 createNativeObject(options) 或 createProtoChains(descriptors)');
  } else {
    recordAddonFallback('createNativeObject', 'addon 不可用，使用 JS options fallback');
  }

  if (isOptions) return createNativeObjectFromOptionsFallback(arg1);
  return createNativeObjectFallback(arg1, arg2, arg3 || {});
}

function normalizeProtoChainArgs(arg1, arg2, arg3) {
  if (Array.isArray(arg1)) return { descriptors: arg1, addon: arg2, legacy: false };
  if (arg1 && typeof arg1 === 'object' && Array.isArray(arg1.descriptors)) return { descriptors: arg1.descriptors, addon: arg1.addon || arg2, legacy: false };
  return { descriptors: Array.isArray(arg2) ? arg2 : [], addon: arg3, legacy: true, name: arg1 };
}

function callConstructorForFallback(desc, thisValue, isNew, args) {
  if (typeof desc.constructor !== 'function') return undefined;
  return desc.constructor.apply(thisValue, [isNew, ...args]);
}

function createProtoChainsFallback(descriptors = []) {
  const registry = new Map();
  const result = {};

  for (const desc of descriptors) {
    if (!desc || typeof desc !== 'object' || !desc.name) continue;

    if (desc.aliasOf) {
      const aliased = registry.get(desc.aliasOf) || result[desc.aliasOf];
      if (aliased) {
        registry.set(desc.name, aliased);
        result[desc.name] = aliased;
      }
      continue;
    }

    const name = desc.name;
    const Ctor = function (...args) {
      const isNew = !!new.target;
      const behavior = desc.illegalConstructor
        ? 'throw'
        : (isNew ? desc.constructorBehavior : desc.callBehavior) || 'allow';
      if (behavior === 'illegal' || behavior === 'throw') {
        const message = isNew
          ? (desc.constructorErrorMessage || illegalConstructorMessage(name))
          : (desc.callErrorMessage || 'Illegal constructor');
        return throwBrowserTypeError(message, null);
      }
      return callConstructorForFallback(desc, this, isNew, args);
    };
    setFunctionMeta(Ctor, name, desc.length ?? 0);
    markNativeFunction(Ctor, name);

    try {
      Object.defineProperty(Ctor.prototype, 'constructor', {
        value: Ctor,
        writable: true,
        enumerable: false,
        configurable: true,
      });
    } catch {}

    const parentName = desc.prototypeParent || desc.parent;
    const parentCtor = parentName ? registry.get(parentName) : null;
    if (parentCtor) {
      try { Object.setPrototypeOf(Ctor.prototype, parentCtor.prototype); } catch {}
    }

    const constructorParentName = Object.prototype.hasOwnProperty.call(desc, 'constructorParent') ? desc.constructorParent : parentName;
    if (constructorParentName) {
      const parent = registry.get(constructorParentName);
      if (parent) try { Object.setPrototypeOf(Ctor, parent); } catch {}
    }

    if (desc.hasToStringTag !== false) {
      try {
        Object.defineProperty(Ctor.prototype, Symbol.toStringTag, {
          value: desc.toStringTag || name,
          writable: false,
          enumerable: false,
          configurable: true,
        });
      } catch {}
    }

    for (const method of Array.isArray(desc.prototypeMethods) ? desc.prototypeMethods : []) {
      if (!method || !method.name || typeof (method.callback || method.value) !== 'function') continue;
      defineValue(
        Ctor.prototype,
        method.name,
        createNativeFunction(method.name, method.length ?? 0, method.callback || method.value, null),
        {
          writable: method.writable ?? true,
          enumerable: method.enumerable ?? true,
          configurable: method.configurable ?? true,
        }
      );
    }

    for (const method of Array.isArray(desc.staticMethods) ? desc.staticMethods : []) {
      if (!method || !method.name || typeof (method.callback || method.value) !== 'function') continue;
      defineValue(
        Ctor,
        method.name,
        createNativeFunction(method.name, method.length ?? 0, method.callback || method.value, null),
        {
          writable: method.writable ?? true,
          enumerable: method.enumerable ?? true,
          configurable: method.configurable ?? true,
        }
      );
    }

    if (desc.readOnlyPrototypeProperty || desc.isReadOnlyPrototype) {
      try { Object.defineProperty(Ctor, 'prototype', { writable: false }); } catch {}
    }
    if (desc.immutablePrototypeObject || desc.isImmutableProto) {
      try { Object.preventExtensions(Ctor.prototype); } catch {}
    }

    registry.set(name, Ctor);
    result[name] = Ctor;

    for (const alias of Array.isArray(desc.aliases) ? desc.aliases : []) {
      registry.set(alias, Ctor);
      result[alias] = Ctor;
    }

    if (desc.instanceFactoryName) {
      const factory = function (...args) {
        const instance = Object.create(Ctor.prototype);
        if (typeof desc.instanceInitializer === 'function') desc.instanceInitializer.apply(instance, args);
        if (desc.immutableInstancePrototype || desc.isImmutableInstanceProto) {
          try { Object.preventExtensions(instance); } catch {}
        }
        markObjectToString(instance, desc.internalClassName || desc.toStringTag || name);
        return instance;
      };
      setFunctionMeta(factory, desc.instanceFactoryName, 0);
      markNativeFunction(factory, desc.instanceFactoryName);
      result[desc.instanceFactoryName] = factory;
    }

    if (desc.isCreateInstance && desc.instanceName) {
      const instance = Object.create(Ctor.prototype);
      if (typeof desc.instanceInitializer === 'function') desc.instanceInitializer.call(instance);
      markObjectToString(instance, desc.internalClassName || desc.toStringTag || name);
      result[desc.instanceName] = instance;
    }
  }

  return result;
}

function createProtoChains(arg1, arg2, arg3) {
  const { descriptors, addon, legacy } = normalizeProtoChainArgs(arg1, arg2, arg3);
  const api = getAddonApi(addon, 'createProtoChains');

  if (!legacy && api) {
    try {
      const result = api(descriptors);
      recordAddonUse('createProtoChains');
      return result;
    } catch (err) {
      recordAddonFallback('createProtoChains', err && err.message ? err.message : String(err));
    }
  } else if (legacy) {
    recordAddonFallback('createProtoChains', '检测到旧式 createProtoChains(name, chain) 调用，新代码应迁移为 createProtoChains(descriptors)');
  } else {
    recordAddonFallback('createProtoChains', 'addon 不可用，使用 JS 构造函数 / 原型链 fallback');
  }

  if (legacy) {
    let current = null;
    const created = [];
    for (const item of descriptors) {
      const proto = Object.create(current || Object.prototype);
      if (item && item.name) markObjectToString(proto, item.name);
      created.push(proto);
      current = proto;
    }
    return created;
  }

  return createProtoChainsFallback(descriptors);
}

function getProtoChainRegistry(addon) {
  const api = getAddonApi(addon, 'getProtoChainRegistry');
  if (api) {
    try {
      const value = api();
      recordAddonUse('getProtoChainRegistry');
      return value;
    } catch (err) {
      recordAddonFallback('getProtoChainRegistry', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('getProtoChainRegistry', 'addon 不可用，无法读取 native 注册表');
  }
  return { constructors: [], aliases: {} };
}

function deleteProtoChainRegistryEntry(name, addon) {
  const api = getAddonApi(addon, 'deleteProtoChainRegistryEntry');
  if (api) {
    try {
      const ok = api(String(name));
      recordAddonUse('deleteProtoChainRegistryEntry');
      return ok;
    } catch (err) {
      recordAddonFallback('deleteProtoChainRegistryEntry', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('deleteProtoChainRegistryEntry', 'addon 不可用，无法删除 native 注册表项');
  }
  return false;
}

function clearProtoChainRegistry(addon) {
  const api = getAddonApi(addon, 'clearProtoChainRegistry');
  if (api) {
    try {
      const ok = api();
      recordAddonUse('clearProtoChainRegistry');
      return ok;
    } catch (err) {
      recordAddonFallback('clearProtoChainRegistry', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('clearProtoChainRegistry', 'addon 不可用，无法清空 native 注册表');
  }
  return false;
}

function normalizeCollectionItems(items) {
  if (!Array.isArray(items)) return [];
  return items.map((item, index) => {
    if (item && typeof item === 'object' && Object.prototype.hasOwnProperty.call(item, 'value')) {
      return { name: item.name == null ? '' : String(item.name), value: item.value };
    }
    return { name: item && item.name ? String(item.name) : String(index), value: item };
  });
}

function createNativeCollection(options = {}, addon) {
  const api = getAddonApi(addon || options.addon, 'createNativeCollection');
  if (api) {
    try {
      const value = api(options);
      recordAddonUse('createNativeCollection');
      return value;
    } catch (err) {
      recordAddonFallback('createNativeCollection', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('createNativeCollection', 'addon 不可用，使用最小集合 JS fallback');
  }

  const name = options.name || 'NativeCollection';
  const Ctor = createNativeConstructor(name, 0, function () {
    throwTypeError(`Failed to construct '${name}': Illegal constructor`, null);
  }, null);
  const collection = Object.create(Ctor.prototype);
  const items = normalizeCollectionItems(options.items);
  const values = items.map(item => item.value);

  defineValue(collection, 'length', values.length, { writable: false, enumerable: false, configurable: true });
  if (options.indexedAccess !== false) {
    values.forEach((value, index) => {
      defineValue(collection, String(index), value, { writable: false, enumerable: true, configurable: true });
    });
  }
  if (options.namedAccess !== false) {
    for (const item of items) {
      if (!item.name) continue;
      defineValue(collection, item.name, item.value, {
        writable: false,
        enumerable: !!options.namedEnumerable,
        configurable: true,
      });
    }
  }
  if (options.itemMethod !== false) {
    defineValue(Ctor.prototype, 'item', createNativeFunction('item', 1, function (index) {
      const n = Number(index);
      return Number.isInteger(n) && n >= 0 ? (this[String(n)] || null) : null;
    }, null), { writable: true, enumerable: false, configurable: true });
  }
  if (options.namedItemMethod !== false) {
    defineValue(Ctor.prototype, 'namedItem', createNativeFunction('namedItem', 1, function (key) {
      return this[String(key)] || null;
    }, null), { writable: true, enumerable: false, configurable: true });
  }
  if (options.iterable !== false) {
    defineValue(Ctor.prototype, Symbol.iterator, createNativeFunction('values', 0, function () {
      return values[Symbol.iterator]();
    }, null), { writable: true, enumerable: false, configurable: true });
  }
  if (options.hasToStringTag !== false) {
    try {
      Object.defineProperty(Ctor.prototype, Symbol.toStringTag, {
        value: options.toStringTag || name,
        writable: false,
        enumerable: false,
        configurable: true,
      });
    } catch {}
  }
  markObjectToString(collection, options.internalClassName || options.toStringTag || name);
  if (options.immutableInstancePrototype) {
    try { Object.preventExtensions(collection); } catch {}
  }
  return { collection, constructor: Ctor, [name]: Ctor };
}

function normalizeMimePluginArgs(configOrAddon, maybeAddon) {
  if (configOrAddon && typeof configOrAddon === 'object' && Object.prototype.hasOwnProperty.call(configOrAddon, 'config')) {
    return { config: configOrAddon.config, addon: configOrAddon.addon || maybeAddon };
  }
  if (isAddonLike(configOrAddon)) return { config: undefined, addon: configOrAddon };
  return { config: configOrAddon, addon: maybeAddon };
}

function getMimeTypesAndPlugins(configOrAddon, maybeAddon) {
  const { config, addon } = normalizeMimePluginArgs(configOrAddon, maybeAddon);
  const api = getAddonApi(addon, 'getMimeTypesAndPlugins');
  if (api) {
    try {
      const result = config === undefined ? api() : api(config);
      recordAddonUse('getMimeTypesAndPlugins');
      return result;
    } catch (err) {
      recordAddonFallback('getMimeTypesAndPlugins', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('getMimeTypesAndPlugins', 'addon 不可用，使用最小 PluginArray / MimeTypeArray fallback');
  }

  const Plugin = createNativeConstructor('Plugin', 0, function () {
    throwTypeError("Failed to construct 'Plugin': Illegal constructor", null);
  }, null);
  const MimeType = createNativeConstructor('MimeType', 0, function () {
    throwTypeError("Failed to construct 'MimeType': Illegal constructor", null);
  }, null);
  const pluginConfigs = config && Array.isArray(config.plugins)
    ? config.plugins
    : [
      { name: 'PDF Viewer', filename: 'internal-pdf-viewer', description: 'Portable Document Format', mimeTypes: [{ type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' }] },
      { name: 'Chrome PDF Viewer', filename: 'internal-pdf-viewer', description: 'Portable Document Format', mimeTypes: [{ type: 'text/pdf', suffixes: 'pdf', description: 'Portable Document Format' }] },
    ];
  const pluginItems = [];
  const mimeItems = [];

  for (const pluginConfig of pluginConfigs) {
    const plugin = Object.create(Plugin.prototype);
    defineValue(plugin, 'name', String(pluginConfig.name || ''), { writable: false, enumerable: true, configurable: true });
    defineValue(plugin, 'filename', String(pluginConfig.filename || ''), { writable: false, enumerable: true, configurable: true });
    defineValue(plugin, 'description', String(pluginConfig.description || ''), { writable: false, enumerable: true, configurable: true });
    markObjectToString(plugin, 'Plugin');

    const localMimes = [];
    for (const mimeConfig of Array.isArray(pluginConfig.mimeTypes) ? pluginConfig.mimeTypes : []) {
      const mime = Object.create(MimeType.prototype);
      defineValue(mime, 'type', String(mimeConfig.type || ''), { writable: false, enumerable: true, configurable: true });
      defineValue(mime, 'suffixes', String(mimeConfig.suffixes || ''), { writable: false, enumerable: true, configurable: true });
      defineValue(mime, 'description', String(mimeConfig.description || ''), { writable: false, enumerable: true, configurable: true });
      defineValue(mime, 'enabledPlugin', plugin, { writable: false, enumerable: true, configurable: true });
      markObjectToString(mime, 'MimeType');
      localMimes.push(mime);
      mimeItems.push({ name: mime.type, value: mime });
    }

    defineValue(plugin, 'length', localMimes.length, { writable: false, enumerable: false, configurable: true });
    localMimes.forEach((mime, index) => defineValue(plugin, String(index), mime, { writable: false, enumerable: true, configurable: true }));
    defineValue(plugin, Symbol.iterator, createNativeFunction('values', 0, function () {
      return localMimes[Symbol.iterator]();
    }, null), { writable: true, enumerable: false, configurable: true });
    pluginItems.push({ name: plugin.name, value: plugin });
  }

  const pluginCollection = createNativeCollection({ name: 'PluginArray', items: pluginItems, toStringTag: 'PluginArray' }, null);
  const mimeCollection = createNativeCollection({ name: 'MimeTypeArray', items: mimeItems, toStringTag: 'MimeTypeArray' }, null);
  const plugins = pluginCollection.collection;
  const mimeTypes = mimeCollection.collection;
  const PluginArray = pluginCollection.PluginArray || pluginCollection.constructor;
  const MimeTypeArray = mimeCollection.MimeTypeArray || mimeCollection.constructor;
  return { mimeTypes, plugins, PluginArray, MimeTypeArray, MimeType, Plugin };
}

function setPrivate(object, key, value, addon) {
  const api = getAddonApi(addon, 'setPrivate');
  if (api) {
    try {
      const ok = api(object, String(key), value);
      recordAddonUse('setPrivate');
      return ok;
    } catch (err) {
      recordAddonFallback('setPrivate', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('setPrivate', 'addon 不可用，使用 WeakMap fallback');
  }
  let map = privateStore.get(object);
  if (!map) {
    map = new Map();
    privateStore.set(object, map);
  }
  map.set(String(key), value);
  return true;
}

function getPrivate(object, key, addon) {
  const api = getAddonApi(addon, 'getPrivate');
  if (api) {
    try {
      const value = api(object, String(key));
      recordAddonUse('getPrivate');
      return value;
    } catch (err) {
      recordAddonFallback('getPrivate', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('getPrivate', 'addon 不可用，使用 WeakMap fallback');
  }
  const map = privateStore.get(object);
  return map ? map.get(String(key)) : undefined;
}

function hasPrivate(object, key, addon) {
  const api = getAddonApi(addon, 'hasPrivate');
  if (api) {
    try {
      const ok = api(object, String(key));
      recordAddonUse('hasPrivate');
      return ok;
    } catch (err) {
      recordAddonFallback('hasPrivate', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('hasPrivate', 'addon 不可用，使用 WeakMap fallback');
  }
  const map = privateStore.get(object);
  return !!(map && map.has(String(key)));
}

function deletePrivate(object, key, addon) {
  const api = getAddonApi(addon, 'deletePrivate');
  if (api) {
    try {
      const ok = api(object, String(key));
      recordAddonUse('deletePrivate');
      return ok;
    } catch (err) {
      recordAddonFallback('deletePrivate', err && err.message ? err.message : String(err));
    }
  } else {
    recordAddonFallback('deletePrivate', 'addon 不可用，使用 WeakMap fallback');
  }
  const map = privateStore.get(object);
  return map ? map.delete(String(key)) : false;
}

function throwTypeError(message, addon) {
  const api = getAddonApi(addon, 'throwTypeError');
  if (api) {
    recordAddonUse('throwTypeError');
    return api(String(message));
  }
  throw new TypeError(String(message));
}

function throwBrowserTypeError(message, addon) {
  return throwTypeError(String(message), addon);
}

function illegalConstructorMessage(name) {
  return `Failed to construct '${String(name)}': Illegal constructor`;
}

function constructorRequiresNewMessage(name) {
  return `Failed to construct '${String(name)}': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`;
}

function throwIllegalConstructor(name, addon) {
  return throwBrowserTypeError(illegalConstructorMessage(name), addon);
}

function throwConstructorRequiresNew(name, addon) {
  return throwBrowserTypeError(constructorRequiresNewMessage(name), addon);
}

function defineNativeValue(obj, key, impl, options = {}, addon) {
  const fn = createNativeFunction(options.name || String(key), options.length ?? impl.length, impl, addon);
  return defineValue(obj, key, fn, {
    writable: options.writable ?? true,
    enumerable: options.enumerable ?? true,
    configurable: options.configurable ?? true,
  });
}

function defineNativeGetter(obj, key, impl, options = {}, addon) {
  const getter = createNativeGetter(options.name || String(key), impl, addon);
  return defineGetter(obj, key, getter, options);
}

function defineNativeSetter(obj, key, impl, options = {}, addon) {
  const setter = createNativeSetter(options.name || String(key), impl, addon);
  return defineSetter(obj, key, setter, options);
}

function defineNativeAccessor(obj, key, accessors = {}, options = {}, addon) {
  const descriptor = {
    enumerable: options.enumerable ?? true,
    configurable: options.configurable ?? true,
  };
  if (typeof accessors.get === 'function') descriptor.get = createNativeGetter(options.getName || String(key), accessors.get, addon);
  if (typeof accessors.set === 'function') descriptor.set = createNativeSetter(options.setName || String(key), accessors.set, addon);
  Object.defineProperty(obj, key, descriptor);
  return descriptor;
}

module.exports = {
  NativeProtect,
  getNativeProtect,
  markNativeFunction,
  markObjectToString,
  nativeAddonCandidates,
  loadNativeAddon,
  setNativeAddon,
  getNativeAddon,
  normalizeAddon,
  getAddonApi,
  getNativeAddonUsage,
  defineValue,
  defineGetter,
  defineSetter,
  createNativeFunction,
  createNativeConstructor,
  createNativeGetter,
  createNativeSetter,
  createUndetectable,
  createInterceptor,
  createNativeObject,
  createProtoChains,
  getProtoChainRegistry,
  deleteProtoChainRegistryEntry,
  clearProtoChainRegistry,
  createNativeCollection,
  getMimeTypesAndPlugins,
  setPrivate,
  getPrivate,
  hasPrivate,
  deletePrivate,
  throwTypeError,
  throwBrowserTypeError,
  illegalConstructorMessage,
  constructorRequiresNewMessage,
  throwIllegalConstructor,
  throwConstructorRequiresNew,
  defineNativeValue,
  defineNativeGetter,
  defineNativeSetter,
  defineNativeAccessor,
};