import type { ComputedRef, Ref, ShallowRef, WritableComputedRef } from 'vue-demi'
import { getCurrentScope, isRef, onScopeDispose, ref, unref, watch } from 'vue-demi'

/**
 * Void函數
 */
export type Fn = () => void

/**
 * 任意函數
 */
export type AnyFn = (...args: any[]) => any

/**
 * 它可能是一個 ref 對象，或者一個普通的值
 */
export type MaybeRef<T = any> =
| T
| Ref<T>
| ShallowRef<T>
| WritableComputedRef<T>

/**
 * 它可能是一個 ref 對象，或者一個普通的值，或者一個 getter 函數
 * @param cb 
 * @param interval 
 */
export type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T)

/**
 * 獲取值、ref 或 getter 的實際值
 */
export function toValue<T>(r: MaybeRefOrGetter<T>): T {
  return typeof r === 'function' ? (r as AnyFn)() : unref(r)
}

/***
 * 是否為客戶端
 */
export const isClient = typeof window !== 'undefined' && typeof document !== 'undefined'

/**
 * 是否處于一個 Vue 3 的響應式 effect 生命周期的作用域內。如果是的話，它會注冊一個清理函數（fn 參數），該函數會在作用域結束時執(zhí)行；如果不是在這樣的作用域內，那么它將不做任何操作。
 * @param fn 
 */
export function tryOnScopeDispose(fn: Fn) {
  if (getCurrentScope()) {
    onScopeDispose(fn)
    return true
  }
  return false
}


export interface UseIntervalOptions {
  /**
   * 立即執(zhí)行這個定時器
   */
  immediate?: boolean
  /**
   * 在調用 resume 函數后，立即執(zhí)行回調函數
   */
  immediateCallback?: boolean
}

export interface Pausable {
  /**
   * 一個 ref 表示 pausable 實例是否處于活動狀態(tài)
   */
  isActive: Readonly<Ref<boolean>>
  /**
   * 暫停定時器
   */
  pause: Fn
  /**
   * 恢復定時器
   */
  resume: Fn
}

export function useIntervalFn(cb: Fn, interval: MaybeRefOrGetter<number> = 1000, options: UseIntervalOptions = {}): Pausable {
  const {
    immediate = true,
    immediateCallback = true
  } = options

  let timer: ReturnType<typeof setInterval> | null = null
  const isActive = ref(false)

  function clean() {
    if (timer) {
      clearInterval(timer)
      timer = null
    }
  }

  function pause() {
    isActive.value = false
    clean()
  }

  function resume() {
    const intervalValue = toValue(interval)
    if (intervalValue <= 0) {
      return
    }
    isActive.value = true

    if (immediateCallback){
      cb()
    }

    clean()

    if (isActive.value) {
      timer = setInterval(cb, intervalValue)
    }
  }

  
  if (immediate && isClient) {
    resume()
  }

  if (isRef(interval) || typeof interval === 'function') {
    const stopWatch = watch(interval, () => {
      if (isActive.value && isClient) {
        resume()
      }
    })
    tryOnScopeDispose(stopWatch)
  }

  tryOnScopeDispose(pause)

  return {
    isActive,
    pause,
    resume
  }
}