import { Promise } from "ext:core/primordials";
import { markPromiseHandled, performPromiseThen } from "ext:core/promise_hooks";
import { isPromise } from "ext:core/event_hooks";

// A thenable avoids Await's PromiseResolve constructor lookup without changing the source.
export function safePromise(value) {
  if (!isPromise(value)) return value;
  return {
    __proto__: null,
    then(resolve, reject) {
      performPromiseThen(value, resolve, reject);
    },
  };
}
export function newPromise(executor) {
  return new Promise((resolve, reject) =>
    executor((value) => resolve(safePromise(value)), reject)
  );
}
export function promiseResolve(value) {
  return newPromise((resolve) => resolve(value));
}
export function promiseReject(reason) {
  return newPromise((_resolve, reject) => reject(reason));
}
export function promiseThen(promise, fulfilled, rejected) {
  return performPromiseThen(
    isPromise(promise) ? promise : promiseResolve(promise),
    (value) =>
      safePromise(typeof fulfilled === "function" ? fulfilled(value) : value),
    (error) => {
      if (typeof rejected === "function") return safePromise(rejected(error));
      throw error;
    },
  );
}
export function promiseAll(values) {
  return newPromise((resolve, reject) => {
    const results = [], count = values.length;
    let remaining = count;
    if (!remaining) resolve(results);
    for (let index = 0; index < count; index++) {
      promiseThen(promiseResolve(values[index]), (value) => {
        results[index] = value;
        if (!--remaining) resolve(results);
      }, reject);
    }
  });
}
export { markPromiseHandled };