import type { ValueReactor } from "../reactor-core/index.ts"
import { effect } from "../reactor-core/index.ts"

export type ValueInitializer<V> = () => V
/**
 * @description This initializer can be used to create a Signal with an undefined initial value which
 * is casted to the desired type T. So the real value getter function will not be called
 * until the Signal is actually used.
 *
 * Every signal should always have a valid value (or value getter which returns a valid value).
 * When using the castValueInitializer, the real value should be set as soon as possible.
 */
export const castValueInitializer = <V>(): ValueInitializer<V> => {
  return (): V => {
    return undefined as unknown as V
  }
}

export type Unsubscribe = () => void
export interface SubscribeOptions<V> {
  target: ValueReactor<V>
  subscriber: (value: V) => void
}
/**
 * @description Subscribes to a ValueReactor and invokes the subscriber when the reactor's value
 * changes.
 *
 * The initial value is skipped; the subscriber is called only on subsequent updates.
 */
export const subscribe = <V>(options: SubscribeOptions<V>): Unsubscribe => {
  const { target, subscriber } = options

  const e = effect((context) => {
    const { isInitializingRun } = context
    const value = target.get()
    if (isInitializingRun === false) {
      subscriber(value)
    }
  })
  const unsubscribe = (): void => {
    e.dispose()
  }
  return unsubscribe
}

// oxlint-disable-next-line no-explicit-any
export type AnyValueReactorArray = Array<ValueReactor<any>>
export type GetValuesInArray<T extends AnyValueReactorArray> = {
  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never
}
export interface GetValuesInArrayOptions<T extends AnyValueReactorArray> {
  target: T
  withoutTrack?: boolean
}
/**
 * @description Gets the current values from an array of ValueReactors.
 */
export const getValuesInArray = <T extends AnyValueReactorArray>(
  options: GetValuesInArrayOptions<T>,
): GetValuesInArray<T> => {
  const valueReactors = options.target
  const withoutTrack = options?.withoutTrack ?? false
  const values = valueReactors.map((vr) => {
    // oxlint-disable-next-line no-unsafe-return
    return withoutTrack ? vr.getWithoutTrack() : vr.get()
  }) as unknown as GetValuesInArray<T>
  return values
}

// oxlint-disable-next-line no-explicit-any
export type AnyValueReactorObject = Record<string, ValueReactor<any>>
export type GetValuesInObject<T extends AnyValueReactorObject> = {
  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never
}
export interface GetValueInObjectOptions<T extends AnyValueReactorObject> {
  target: T
  withoutTrack?: boolean
}
/**
 * @description Gets the current values from an object of ValueReactors.
 */
export const getValuesInObject = <T extends AnyValueReactorObject>(
  options: GetValueInObjectOptions<T>,
): GetValuesInObject<T> => {
  const valueReactors = options.target
  const withoutTrack = options?.withoutTrack ?? false
  const values = {} as GetValuesInObject<T>
  for (const key of Object.keys(valueReactors)) {
    const valueReactor = valueReactors[key]!
    const value = withoutTrack ? valueReactor.getWithoutTrack() : valueReactor.get()
    values[key as unknown as keyof GetValuesInObject<T>] = value
  }
  return values
}