import { create } from "zustand"
import { persist } from "zustand/middleware"

interface TimerStore {
  timer: NodeJS.Timeout | null
  startTimer: (fn: Function, delay: number) => void
  clearTimer: () => void
}

export const useTimerStore = create<TimerStore>((set, get) => ({
  timer: null,
  startTimer: (fn, delay) => {
    const { timer } = get()
    if (timer !== null) {
      clearTimeout(timer)
    }
    const t = setTimeout(() => {
      fn()
    }, delay)
    set({ timer: t })
  },
  clearTimer: () => {
    const { timer } = get()
    if (timer !== null) {
      clearTimeout(timer)
      set({ timer: null })
    }
  },
}))

interface IntervalStore {
  timer: NodeJS.Timeout | null
  startTimer: (fn: Function, delay: number) => void
  clearTimer: () => void
  isAutoSave: boolean
  setIsAutoSave: (isAutoSave: boolean) => void
  autoSaveGap: number
  setAutoSaveGap: (autoSaveGap: number) => void
}

export const useIntervalStore = create<IntervalStore>()(
  persist<IntervalStore>(
    (set, get) => ({
      timer: null,
      isAutoSave: false,
      autoSaveGap: 5,
      startTimer: (fn, delay) => {
        const { timer } = get()
        if (timer !== null) {
          clearInterval(timer)
        }
        const t = setInterval(() => {
          fn()
        }, delay)
        set((state) => ({ ...state, timer: t }))
      },
      clearTimer: () => {
        const { timer } = get()
        if (timer !== null) {
          clearInterval(timer)
          set((state) => ({ ...state, timer: null }))
        }
      },
      setIsAutoSave: (flag: boolean) => {
        set((state) => ({ ...state, isAutoSave: flag }))
      },
      setAutoSaveGap: (value: number) => {
        set((state) => ({ ...state, autoSaveGap: value }))
      },
    }),
    {
      name: "interval-store",
    }
  )
)

export interface LabelTimeState {
  label: number
  review1: number
  review2: number
}

interface LabelTimeStore {
  labelTime: LabelTimeState
  setLabelTime: (
    labelTime: LabelTimeState | ((prev: LabelTimeState) => LabelTimeState)
  ) => void
  resetLabelTime: () => void
}

const initialLabelTimeState: LabelTimeState = {
  label: 0,
  review1: 0,
  review2: 0,
}

export const useLabelTimeStore = create<LabelTimeStore>((set) => ({
  labelTime: initialLabelTimeState,
  setLabelTime: (labelTime) =>
    set((state) => ({
      ...state,
      labelTime:
        typeof labelTime === "function"
          ? labelTime(state.labelTime)
          : labelTime,
    })),
  resetLabelTime: () =>
    set((state) => ({
      ...state,
      labelTime: initialLabelTimeState,
    })),
}))