import type { Signal, ValueReactor } from "../reactor-core/index.ts"
import { signal } from "../reactor-core/index.ts"

import { subscribe } from "./utility.ts"

export interface FromPromiseSyncOptions<V> {
  target: Promise<V>
}
/**
 * @description Converts a Promise into a Signal that updates its value
 * when the Promise resolves.
 *
 * @see {@link fromPromiseAsync} for an async version.
 */
export const fromPromiseSync = <V>(options: FromPromiseSyncOptions<V>): Signal<V | undefined> => {
  const { target } = options

  const result = signal<V | undefined>(() => undefined)
  void target.then((value) => {
    return result.set(value)
  })
  return result
}

export interface FromPromiseAsyncOptions<V> {
  target: Promise<V>
}
/**
 * @description Converts a Promise into a Signal that is initialized
 * with the resolved value of the Promise.
 *
 * @see {@link fromPromiseSync} for a sync version.
 */
export const fromPromiseAsync = async <V>(
  options: FromPromiseAsyncOptions<V>,
): Promise<Signal<V>> => {
  const { target } = options

  const value = await target
  const result = signal<V>(() => value)
  return result
}

export interface ToPromiseOptions<V> {
  target: ValueReactor<V>
}
/**
 * @description Converts a ValueReactor into a Promise that resolves
 * with the next value emitted by the ValueReactor.
 */
export const toPromise = async <V>(options: ToPromiseOptions<V>): Promise<V> => {
  const { target } = options

  let _resolve: (value: V) => void
  const promise = new Promise<V>((resolve) => {
    _resolve = resolve
  })
  const unsubscribe = subscribe({
    target,
    subscriber: (value) => {
      unsubscribe()
      _resolve(value)
    },
  })
  return await promise
}