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

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

export interface TapOptions<R extends AnyValueReactor> {
  target: R
  tapper?: ((value: ValueOfValueReactor<R>) => void) | undefined
}
/**
 * @description Taps into the value changes of a ValueReactor without modifying its value.
 */
export const tap = <R extends AnyValueReactor>(options: TapOptions<R>): R => {
  const { target, tapper = (value: ValueOfValueReactor<R>): void => console.log(value) } = options

  effect(() => {
    const value = target.get() as ValueOfValueReactor<R>
    tapper(value)
  })

  return target
}

export interface WithHistoryOptions<V> {
  target: ValueReactor<V>
}
/**
 * @description Creates a signal that maintains a history of values from a ValueReactor.
 * The history is stored in an array, with each new value appended to the end.
 *
 * Note: This implementation does not limit the size of the history array. Use
 * with caution to avoid excessive memory usage.
 */
export const withHistory = <V>(options: WithHistoryOptions<V>): Signal<V[]> => {
  const { target } = options

  const result = signal(castValueInitializer<V[]>(), {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const history: V[] = []
  const eTarget = effect(() => {
    history.push(target.get())
    result.set([...history])
  })

  return result
}

export interface BufferByCountOptions<V> {
  target: ValueReactor<V>
  count: number
}
/**
 * @description Buffers values from a ValueReactor and emits them as an array
 * when the number of buffered values reaches the specified count.
 */
export const bufferByCount = <V>(options: BufferByCountOptions<V>): Signal<V[]> => {
  const { target, count } = options

  if (count <= 0) {
    throw new Error("bufferByCount operator requires count to be greater than 0")
  }

  const result = signal<V[]>(() => [], {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const bufferedValues: V[] = []
  const eTarget = effect(() => {
    bufferedValues.push(target.get())
    if (bufferedValues.length >= count) {
      result.set([...bufferedValues])
      bufferedValues.length = 0
    }
  })

  return result
}

export interface BufferByTimeOptions<V> {
  target: ValueReactor<V>
  time: number
}
/**
 * @description Buffers values from a ValueReactor and emits them as an array
 * at specified time intervals.
 */
export const bufferByTime = <V>(options: BufferByTimeOptions<V>): Signal<V[]> => {
  const { target, time } = options

  if (time <= 0) {
    throw new Error("bufferByTime operator requires timeInMilliseconds to be greater than 0")
  }

  const result = signal<V[]>(() => [], {
    onDispose: () => {
      eTarget.dispose()
      clearInterval(intervalId)
    },
  })

  const bufferedValues: V[] = []
  const eTarget = effect(() => {
    bufferedValues.push(target.get())
  })

  const intervalId = setInterval(() => {
    result.set([...bufferedValues])
    bufferedValues.length = 0
  }, time)

  return result
}

export interface BufferByTriggerOptions<VTarget, VTrigger> {
  target: ValueReactor<VTarget>
  trigger: ValueReactor<VTrigger>
}
/**
 * @description Buffers values from a ValueReactor and emits them as an array when the trigger ValueReactor
 * changes.
 */
export const bufferByTrigger = <VTarget, VTrigger>(
  options: BufferByTriggerOptions<VTarget, VTrigger>,
): Signal<VTarget[]> => {
  const { target, trigger } = options

  const result = signal(castValueInitializer<VTarget[]>(), {
    onDispose: () => {
      eTarget.dispose()
      eTrigger.dispose()
    },
  })

  const bufferedValues: VTarget[] = []
  const eTarget = effect(() => {
    bufferedValues.push(target.get())
  })

  const eTrigger = effect(() => {
    trigger.get()
    result.set([...bufferedValues])
    bufferedValues.length = 0
  })

  return result
}

export interface BufferByToggleOptions<VTarget, VOpen, VClose> {
  target: ValueReactor<VTarget>
  open: ValueReactor<VOpen>
  close: ValueReactor<VClose>
}
/**
 * @description Buffers values from a ValueReactor and emits them as an array
 * when the open ValueReactor emits a value, and stops buffering
 * when the close ValueReactor emits a value.
 */
export const bufferByToggle = <VTarget, VOpen, VClose>(
  options: BufferByToggleOptions<VTarget, VOpen, VClose>,
): Signal<VTarget[]> => {
  const { target, open, close } = options

  const result = signal(castValueInitializer<VTarget[]>(), {
    onDispose: () => {
      eTarget.dispose()
      eOpen.dispose()
      eClose.dispose()
    },
  })

  const bufferedValues: VTarget[] = []
  let buffering = false

  const eOpen = effect(() => {
    open.get()
    buffering = true
  })

  const eTarget = effect(() => {
    const value = target.get()
    if (buffering === true) {
      bufferedValues.push(value)
    }
  })

  const eClose = effect(() => {
    close.get()
    if (buffering === true) {
      result.set([...bufferedValues])
      bufferedValues.length = 0
      buffering = false
    }
  })

  return result
}

export interface BufferByDynamicOptions<VTarget, VDynamic> {
  target: ValueReactor<VTarget>
  dynamic: (value: VTarget) => ValueReactor<VDynamic>
}
/**
 * @description Buffers values from a ValueReactor and emits them as an array
 * when the ValueReactor returned by the `dynamic` function emits a value.
 * The `dynamic` function is called each time the buffer is emitted
 * to get a new ValueReactor for the next buffer.
 */
export const bufferByDynamic = <VTarget, VDynamic>(
  options: BufferByDynamicOptions<VTarget, VDynamic>,
): Signal<VTarget[]> => {
  const { target, dynamic } = options

  const result = signal(castValueInitializer<VTarget[]>(), {
    onDispose: () => {
      eTarget.dispose()
      eDynamic.dispose()
    },
  })

  const bufferedValues: VTarget[] = []
  const eTarget = effect(() => {
    const value = target.get()
    bufferedValues.push(value)
  })

  let trigger: ValueReactor<VDynamic> | undefined = undefined
  const eDynamic = effect(() => {
    trigger?.dispose()
    const targetValue = target.getWithoutTrack()
    trigger = dynamic(targetValue)
    trigger.get()
    result.set([...bufferedValues])
    bufferedValues.length = 0
  })

  return result
}

export interface GroupToArrayByOptions<V, K> {
  target: ValueReactor<V>
  keyGetter: (value: V) => K
}
/**
 * @description Groups values from a ValueReactor into an array of arrays based on a key
 * extracted by the keyGetter function.
 */
export const groupToArrayBy = <V, K>(options: GroupToArrayByOptions<V, K>): Signal<V[][]> => {
  const { target, keyGetter } = options

  const result = signal<V[][]>(() => [], {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const groups = new Map<K, V[]>()
  const eTarget = effect(() => {
    const value = target.get()
    const key = keyGetter(value)
    if (groups.has(key) === false) {
      groups.set(key, [])
      result.set([...groups.values()])
    }
    const groupedArray = groups.get(key)!
    groupedArray.push(value)
  })

  return result
}

export interface GroupToObjectByOptions<V, K extends string | number | symbol> {
  target: ValueReactor<V>
  keyGetter: (value: V) => K
}
/**
 * @description Groups values from a ValueReactor into an object where each key maps to an array
 * of values corresponding to that key.
 */
export const groupToObjectBy = <V, K extends string | number | symbol>(
  options: GroupToObjectByOptions<V, K>,
): Signal<Record<K, V[]>> => {
  const { target, keyGetter } = options

  const result = signal<Record<K, V[]>>(
    () => {
      return {} as Record<K, V[]>
    },
    {
      onDispose: () => {
        eTarget.dispose()
      },
    },
  )

  const groups = new Map<K, V[]>()
  const eTarget = effect(() => {
    const value = target.get()
    const key = keyGetter(value)
    if (groups.has(key) === false) {
      groups.set(key, [])
      result.set(Object.fromEntries(groups.entries()) as Record<K, V[]>)
    }
    const groupedArray = groups.get(key)!
    groupedArray.push(value)
  })

  return result
}

/**
 * @description Groups values from a ValueReactor into an array of Signals based on a key
 * extracted by the keyGetter function.
 */
export const groupToSignalArrayBy = <V, K>(
  target: ValueReactor<V>,
  keyGetter: (value: V) => K,
): Signal<Array<Signal<V[]>>> => {
  const result = signal<Array<Signal<V[]>>>(() => [], {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const groups = new Map<K, Signal<V[]>>()
  const eTarget = effect(() => {
    const value = target.get()
    const key = keyGetter(value)
    if (groups.has(key) === false) {
      const newGroup = signal<V[]>(() => [])
      groups.set(key, newGroup)
      result.set([...groups.values()])
    }
    const groupedSignal = groups.get(key)!
    const currentArray = groupedSignal.get()
    groupedSignal.set([...currentArray, value])
  })

  return result
}

export interface GroupToSignalObjectByOptions<V, K extends string | number | symbol> {
  target: ValueReactor<V>
  keyGetter: (value: V) => K
}
/**
 * @description Groups values from a ValueReactor into a Signal of an object where each key maps to a Signal
 * of an array of values corresponding to that key.
 */
export const groupToSignalObjectBy = <V, K extends string | number | symbol>(
  options: GroupToSignalObjectByOptions<V, K>,
): Signal<Record<K, Signal<V[]>>> => {
  const { target, keyGetter } = options

  const result = signal<Record<K, Signal<V[]>>>(
    () => {
      return {} as Record<K, Signal<V[]>>
    },
    {
      onDispose: () => {
        eTarget.dispose()
      },
    },
  )

  const groups = new Map<K, Signal<V[]>>()
  const eTarget = effect(() => {
    const value = target.get()
    const key = keyGetter(value)
    if (groups.has(key) === false) {
      const newGroup = signal<V[]>(() => [])
      groups.set(key, newGroup)
      result.set(Object.fromEntries(groups.entries()) as Record<K, Signal<V[]>>)
    }
    const groupedSignal = groups.get(key)!
    const currentArray = groupedSignal.get()
    groupedSignal.set([...currentArray, value])
  })

  return result
}

export interface MapOptions<VTarget, VMapped> {
  target: ValueReactor<VTarget>
  mapper: (value: VTarget) => VMapped
}
/**
 * @description Maps values from a ValueReactor using the provided mapper function and
 * emits the mapped values as a new Signal.
 */
export const map = <VTarget, VMapped>(options: MapOptions<VTarget, VMapped>): Signal<VMapped> => {
  const { target, mapper } = options

  const result = signal(castValueInitializer<VMapped>(), {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const eTarget = effect(() => {
    const value = target.get()
    const newValue = mapper(value)
    result.set(newValue)
  })

  return result
}

export interface ContextualMapInitializingMapperContext<VTarget> {
  isInitializingRun: true
  targetValue: VTarget
}
export interface ContextualMapUpdatingMapperContext<VTarget, VMapped> {
  isInitializingRun: false
  targetValue: VTarget
  previousMappedValue: VMapped
}
export type ContextualMapMapperContextOf<VTarget, VMapped> =
  | ContextualMapInitializingMapperContext<VTarget>
  | ContextualMapUpdatingMapperContext<VTarget, VMapped>

export interface ContextualMapOptions<VTarget, VMapped> {
  target: ValueReactor<VTarget>
  mapper: (context: ContextualMapMapperContextOf<VTarget, VMapped>) => VMapped
}
/**
 * @description Maps values from a ValueReactor using the provided contextual mapper function and
 * emits the mapped values as a new Signal.
 */
export const contextualMap = <VTarget, VMapped>(
  options: ContextualMapOptions<VTarget, VMapped>,
): Signal<VMapped> => {
  const { target, mapper } = options

  const result = signal(castValueInitializer<VMapped>(), {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const eTarget = effect((context) => {
    const targetValue = target.get()
    const { isInitializingRun } = context
    if (isInitializingRun === true) {
      const newValue = mapper({
        isInitializingRun,
        targetValue,
      })
      result.set(newValue)
    } else {
      const previousMappedValue = result.getWithoutTrack()
      const newValue = mapper({
        isInitializingRun,
        targetValue,
        previousMappedValue,
      })
      result.set(newValue)
    }
  })

  return result
}

export interface MergeMapOptions<VTarget, VMapped> {
  target: ValueReactor<VTarget>
  mapper: (value: VTarget) => ValueReactor<VMapped>
}
/**
 * @description Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,
 * subscribes to every mapped reactor, and merges their emitted values into a single `Signal<R>`.
 */
export const mergeMap = <VTarget, VMapped>(
  options: MergeMapOptions<VTarget, VMapped>,
): Signal<VMapped> => {
  const { target, mapper } = options

  const result = signal(castValueInitializer<VMapped>(), {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const eTarget = effect(() => {
    const value = target.get()
    const currentMappedReactor = mapper(value)

    effect(() => {
      const mappedValue = currentMappedReactor.get()
      result.set(mappedValue)
    })
  })

  return result
}

export interface SwitchMapOptions<VTarget, VMapped> {
  target: ValueReactor<VTarget>
  mapper: (value: VTarget) => ValueReactor<VMapped>
}
/**
 * @description Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,
 * subscribes only to the latest mapped reactor, and emits its values as a `Signal<R>`.
 */
export const switchMap = <VTarget, VMapped>(
  options: SwitchMapOptions<VTarget, VMapped>,
): Signal<VMapped> => {
  const { target, mapper } = options

  const result = signal(castValueInitializer<VMapped>(), {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  let lastMappedReactor: ValueReactor<VMapped> | undefined = undefined

  const eTarget = effect(() => {
    const value = target.get()
    lastMappedReactor?.dispose()
    lastMappedReactor = mapper(value)
    effect(() => {
      const mappedValue = lastMappedReactor!.get()
      result.set(mappedValue)
    })
  })

  return result
}

export interface ScanOptions<VTarget, VAccumulated> {
  target: ValueReactor<VTarget>
  accumulator: (acc: VAccumulated, value: VTarget) => VAccumulated
  seed: VAccumulated
}
/**
 * @description Accumulates values from a ValueReactor using the provided accumulator function
 * and emits the accumulated value as a Signal.
 */
export const scan = <VTarget, VAccumulated>(
  options: ScanOptions<VTarget, VAccumulated>,
): Signal<VAccumulated> => {
  const { target, accumulator, seed } = options

  const result = signal(() => seed, {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  const eTarget = effect(() => {
    const value = target.get()
    const newValue = accumulator(result.getWithoutTrack(), value)
    result.set(newValue)
  })

  return result
}

export interface PairwiseOptions<V> {
  target: ValueReactor<V>
}
/**
 * @description Emits the previous and current values from a ValueReactor as a tuple.
 * The first emitted tuple will have `undefined` as the previous value.
 */
export const pairwise = <V>(options: PairwiseOptions<V>): Signal<[V | undefined, V]> => {
  const { target } = options

  const result = signal<[V | undefined, V]>(() => [undefined, target.get()], {
    onDispose: () => {
      eTarget.dispose()
    },
  })

  let previousValue: V | undefined = undefined
  const eTarget = effect(() => {
    const currentValue = target.get()
    result.set([previousValue, currentValue])
    previousValue = currentValue
  })

  return result
}