// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
//
// SPDX-License-Identifier: Apache-2.0
import { Throws } from './throws';

type InferErrors<T> =
  T extends ThrowsPromise<any, infer E>
    ? E
    : T extends PromiseLike<infer U>
      ? U extends { __throws?(error: infer E): void }
        ? E
        : never
      : never;

interface PromiseRejectedResult<E> {
  status: 'rejected';
  reason: E;
}

type SettledResult<T> =
  T extends ThrowsPromise<infer U, infer E>
    ? PromiseFulfilledResult<U> | PromiseRejectedResult<E>
    : T extends PromiseLike<infer U>
      ? PromiseFulfilledResult<U> | PromiseRejectedResult<unknown>
      : PromiseFulfilledResult<T> | PromiseRejectedResult<unknown>;

export class ThrowsPromise<T, E extends Error> extends Promise<Throws<T, E>> {
  constructor(
    executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void,
  ) {
    super(executor as unknown as ConstructorParameters<typeof Promise<Throws<T, E>>>[0]);
  }

  catch<TResult = never>(
    onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined,
  ): ThrowsPromise<T | TResult, E> {
    return super.catch(onrejected) as unknown as ThrowsPromise<T | TResult, E>;
  }

  static resolve: {
    (): ThrowsPromise<void, never>;
    <V>(value: V): ThrowsPromise<Awaited<V>, never>;
  } = <V>(value?: V): ThrowsPromise<Awaited<V>, never> => {
    return super.resolve(value) as ThrowsPromise<Awaited<V>, never>;
  };

  static reject<E extends Error>(reason: E): ThrowsPromise<never, E> {
    return super.reject(reason) as ThrowsPromise<never, E>;
  }

  static all<T extends readonly unknown[] | []>(
    values: T,
  ): ThrowsPromise<{ -readonly [P in keyof T]: Awaited<T[P]> }, InferErrors<T[number]>> {
    return super.all(values) as any;
  }

  static allSettled<T extends readonly unknown[] | []>(
    values: T,
  ): ThrowsPromise<{ -readonly [P in keyof T]: SettledResult<T[P]> }, never> {
    return super.allSettled(values) as any;
  }

  static race<T extends readonly (ThrowsPromise<any, any> | any)[]>(
    values: T,
  ): ThrowsPromise<
    T[number] extends ThrowsPromise<infer U, any>
      ? U
      : T[number] extends PromiseLike<infer U>
        ? U
        : Awaited<T[number]>,
    InferErrors<T[number]>
  > {
    return super.race(values) as any;
  }

  /** type cast (third party promise) to a ThrowsPromise */
  static fromPromise<T, E extends Error>(promise: Promise<T>): ThrowsPromise<T, E> {
    return promise as ThrowsPromise<T, E>;
  }

  /** type cast that strips the throws type */
  asPromise(): Promise<T> {
    return this;
  }
}