/**
 * Node.js util module polyfill for browser environment.
 * Required by adaptivecards-templating and antlr4ts.
 *
 * @module @burdenoff/fe-libs/shared/shims/util
 */

export function isPromise(value: unknown): value is Promise<unknown> {
  return (
    value !== null &&
    typeof value === 'object' &&
    typeof (value as Promise<unknown>).then === 'function' &&
    typeof (value as Promise<unknown>).catch === 'function'
  );
}

export function isDate(value: unknown): value is Date {
  return value instanceof Date;
}

export function isError(value: unknown): value is Error {
  return value instanceof Error;
}

export function isRegExp(value: unknown): value is RegExp {
  return value instanceof RegExp;
}

export function isArray(value: unknown): value is unknown[] {
  return Array.isArray(value);
}

export function isBuffer(_value: unknown): boolean {
  return false;
}

export function isNullOrUndefined(value: unknown): value is null | undefined {
  return value === null || value === undefined;
}

export function isUndefined(value: unknown): value is undefined {
  return value === undefined;
}

export function isNull(value: unknown): value is null {
  return value === null;
}

export function isBoolean(value: unknown): value is boolean {
  return typeof value === 'boolean';
}

export function isNumber(value: unknown): value is number {
  return typeof value === 'number';
}

export function isString(value: unknown): value is string {
  return typeof value === 'string';
}

export function isSymbol(value: unknown): value is symbol {
  return typeof value === 'symbol';
}

export function isObject(value: unknown): value is object {
  return typeof value === 'object' && value !== null;
}

export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
  return typeof value === 'function';
}

export function isPrimitive(value: unknown): boolean {
  return value === null || (typeof value !== 'object' && typeof value !== 'function');
}

export const inspect = {
  custom: Symbol.for('nodejs.util.inspect.custom'),
};

export function format(fmt: string, ...args: unknown[]): string {
  let i = 0;
  return fmt.replace(/%[sdjifoO%]/g, (match) => {
    if (match === '%%') return '%';
    if (i >= args.length) return match;
    const arg = args[i++];
    switch (match) {
      case '%s':
        return String(arg);
      case '%d':
        return String(Number(arg));
      case '%i':
        return String(parseInt(String(arg), 10));
      case '%f':
        return String(parseFloat(String(arg)));
      case '%j':
        return JSON.stringify(arg);
      case '%o':
      case '%O':
        return JSON.stringify(arg, null, 2);
      default:
        return String(arg);
    }
  });
}

export function inherits(
  ctor: { prototype: object; super_?: unknown },
  superCtor: { prototype: object }
): void {
  ctor.super_ = superCtor;
  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
}

export function deprecate<T extends (...args: unknown[]) => unknown>(fn: T, _msg: string): T {
  return fn;
}

export function promisify<T>(fn: (...args: unknown[]) => void): (...args: unknown[]) => Promise<T> {
  return (...args: unknown[]) =>
    new Promise((resolve, reject) => {
      fn(...args, (err: Error | null, result: T) => {
        if (err) reject(err);
        else resolve(result);
      });
    });
}

export function callbackify<T>(
  fn: (...args: unknown[]) => Promise<T>
): (...args: [...unknown[], (err: Error | null, result?: T) => void]) => void {
  return (...args) => {
    const callback = args.pop() as (err: Error | null, result?: T) => void;
    Promise.resolve(fn(...args))
      .then((result) => callback(null, result))
      .catch((err) => callback(err));
  };
}

export const types = {
  isPromise,
  isDate,
  isRegExp,
  isArray,
  isArrayBuffer: (value: unknown): value is ArrayBuffer => value instanceof ArrayBuffer,
  isArrayBufferView: (value: unknown): boolean => ArrayBuffer.isView(value),
  isAsyncFunction: (value: unknown): boolean =>
    typeof value === 'function' && value.constructor.name === 'AsyncFunction',
  isBigInt64Array: (value: unknown): boolean => value instanceof BigInt64Array,
  isBigUint64Array: (value: unknown): boolean => value instanceof BigUint64Array,
  isBooleanObject: (value: unknown): boolean =>
    typeof value === 'object' && value instanceof Boolean,
  isDataView: (value: unknown): value is DataView => value instanceof DataView,
  isFloat32Array: (value: unknown): boolean => value instanceof Float32Array,
  isFloat64Array: (value: unknown): boolean => value instanceof Float64Array,
  isGeneratorFunction: (value: unknown): boolean =>
    typeof value === 'function' && value.constructor.name === 'GeneratorFunction',
  isGeneratorObject: (value: unknown): boolean =>
    typeof value === 'object' && value !== null && value.constructor.name === 'Generator',
  isInt8Array: (value: unknown): boolean => value instanceof Int8Array,
  isInt16Array: (value: unknown): boolean => value instanceof Int16Array,
  isInt32Array: (value: unknown): boolean => value instanceof Int32Array,
  isMap: (value: unknown): value is Map<unknown, unknown> => value instanceof Map,
  isMapIterator: (_value: unknown): boolean => false,
  isNativeError: isError,
  isNumberObject: (value: unknown): boolean => typeof value === 'object' && value instanceof Number,
  isSet: (value: unknown): value is Set<unknown> => value instanceof Set,
  isSetIterator: (_value: unknown): boolean => false,
  isSharedArrayBuffer: (value: unknown): boolean =>
    typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer,
  isStringObject: (value: unknown): boolean => typeof value === 'object' && value instanceof String,
  isSymbolObject: (value: unknown): boolean =>
    typeof value === 'object' && value !== null && value.constructor === Symbol,
  isTypedArray: (value: unknown): boolean =>
    ArrayBuffer.isView(value) && !(value instanceof DataView),
  isUint8Array: (value: unknown): boolean => value instanceof Uint8Array,
  isUint8ClampedArray: (value: unknown): boolean => value instanceof Uint8ClampedArray,
  isUint16Array: (value: unknown): boolean => value instanceof Uint16Array,
  isUint32Array: (value: unknown): boolean => value instanceof Uint32Array,
  isWeakMap: (value: unknown): value is WeakMap<object, unknown> => value instanceof WeakMap,
  isWeakSet: (value: unknown): value is WeakSet<object> => value instanceof WeakSet,
};

export default {
  isPromise,
  isDate,
  isError,
  isRegExp,
  isArray,
  isBuffer,
  isNullOrUndefined,
  isUndefined,
  isNull,
  isBoolean,
  isNumber,
  isString,
  isSymbol,
  isObject,
  isFunction,
  isPrimitive,
  inspect,
  format,
  inherits,
  deprecate,
  promisify,
  callbackify,
  types,
};