import { Project } from "./api/project/typing"
import { create } from "zustand"
import { persist } from "zustand/middleware"
import { usePaperStore } from "./usePaperStore"
import { useObjectStore } from "./store"
import { useBottomToolsStore } from "./useBottomToolsStore"
import { safeClone } from "./utils/clone"

interface TopToolsState {
  // 标注页面是否仅查看
  isView: boolean
  setIsView: (val: boolean) => void
  renderMode: boolean
  setRenderMode: (val: boolean) => void
  // 绘制模式
  editMode: boolean
  setEditMode: (val: boolean) => void
  // 是否在相交模式下press A键
  pressA: boolean
  setPressA: (val: boolean) => void
  // 亮度 饱和度 对比度
  imageFilter: {
    saturate: number
    contrast: number
    brightness: number
  }
  setImageFilter: (
    key: "saturate" | "contrast" | "brightness",
    val: number
  ) => void
  crosshairStatus: "hidden" | "line" | "carve"
  setCrosshairStatus: (val: "hidden" | "line" | "carve") => void
  assistToolEnabled: boolean
  setAssistToolEnabled: (val: boolean) => void
  assistToolSize: number
  setAssistToolSize: (val: number) => void
  showTags: boolean
  setShowTags: (val: boolean) => void
  showTagsConfigs: string[]
  setShowTagsConfigs: (val: string[]) => void
  // drawOption 图形叠加选项
  drawOption: "default" | "intersect" | "unite"
  setDrawOption: (val: "default" | "intersect" | "unite") => void
  magnetFlag: boolean
  setMagnetFlag: (val: boolean) => void
  saveCurrentScale: boolean
  setSaveCurrentScale: (val: boolean) => void
  scale: number
  setScale: (val: number) => void
  activeOperation: string
  setActiveOperation: (val: string) => void
  showObjectList: boolean
  setShowObjectList: (val: boolean) => void
  showDescList: boolean
  setShowDescList: (val: boolean) => void
  showGroupList: boolean
  setShowGroupList: (val: boolean) => void
  showTaskList: boolean
  setShowTaskList: (val: boolean) => void
  showMultiFrame: boolean
  setShowMultiFrame: (val: boolean) => void
  currentTimeKey: "label" | "review1" | "review2"
  setCurrentTimeKey: (val: "label" | "review1" | "review2") => void
  subAttrPresetShow: boolean
  setSubAttrPresetShow: (val: boolean) => void
  subAttributes: {
    // key: label_class
    [key: string]: {
      [key: string]: string | string[]
    }
  }
  setsubAttributes: (
    key: string,
    val: { [key: string]: string | string[] }
  ) => void
  objectOperations: Project.LabelSchemaList[]
  setObjectOperations: (val: Project.LabelSchemaList[]) => void
  needBackup: boolean
  setNeedBackup: (flag: boolean) => void
  checkSize: number
  setCheckSize: (v: number) => void
}

const initialTopToolsState = {
  isView: false,
  renderMode: false,
  editMode: false,
  pressA: false,
  imageFilter: {
    saturate: 0,
    contrast: 0,
    brightness: 0,
  },
  crosshairStatus: "hidden" as "hidden" | "line" | "carve",
  assistToolEnabled: false,
  assistToolSize: 10,
  drawOption: "default" as "default" | "intersect" | "unite",
  saveCurrentScale: false,
  scale: 1,
  activeOperation: "",
  showObjectList: false,
  showGroupList: false,
  showTaskList: false,
  showMultiFrame: true,
  currentTimeKey: "label" as "label" | "review1" | "review2",
  subAttrPresetShow: false,
  subAttributes: {},
  objectOperations: [],
}

export const useTopToolsStore = create<TopToolsState>()(
  persist<TopToolsState>(
    (set) => ({
      isView: initialTopToolsState.isView,
      setIsView: (val: boolean) =>
        set((state: TopToolsState) => ({
          ...state,
          isView: val,
        })),
      renderMode: initialTopToolsState.renderMode,
      setRenderMode: (val: boolean) =>
        set((state: TopToolsState) => ({
          ...state,
          renderMode: val,
        })),
      editMode: initialTopToolsState.editMode,
      setEditMode: (val: boolean) =>
        set((state: TopToolsState) => ({
          ...state,
          editMode: val,
        })),
      pressA: initialTopToolsState.pressA,
      setPressA: (val: boolean) => {
        if (!val) {
          set((state: TopToolsState) => ({
            ...state,
            pressA: false,
          }))
          return
        }
        let ids =
          useObjectStore.getState().selectedPath[
            useBottomToolsStore.getState().activeImage
          ]
        if (!ids || ids.length !== 1) {
          set((state: TopToolsState) => ({
            ...state,
            pressA: false,
          }))
          return
        }
        let path = usePaperStore.getState().getItemById(ids[0])
        if (path && path.data.type !== "rectangle") {
          let flag = val

          set((state: TopToolsState) => ({
            ...state,
            pressA: flag ? true : false,
          }))
        }
      },
      imageFilter: initialTopToolsState.imageFilter,
      setImageFilter: (key, val) =>
        set((state: TopToolsState) => ({
          ...state,
          imageFilter: Object.assign(state.imageFilter, { [key]: val }),
        })),
      crosshairStatus: initialTopToolsState.crosshairStatus,
      setCrosshairStatus: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          crosshairStatus: val,
        })),
      assistToolEnabled: initialTopToolsState.assistToolEnabled,
      setAssistToolEnabled: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          assistToolEnabled: val,
        })),
      assistToolSize: initialTopToolsState.assistToolSize,
      setAssistToolSize: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          assistToolSize: Math.max(1, val),
        })),
      showTags: false,
      setShowTags: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          showTags: val,
        })),
      showTagsConfigs: [],
      setShowTagsConfigs: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          showTagsConfigs: val,
        })),
      drawOption: initialTopToolsState.drawOption,
      setDrawOption: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          drawOption: val,
        })),
      magnetFlag: false,
      setMagnetFlag: (val) =>
        set((state: TopToolsState) => ({
          ...state,
          magnetFlag: val,
        })),
      saveCurrentScale: initialTopToolsState.saveCurrentScale,
      setSaveCurrentScale: (val: boolean) =>
        set((state: TopToolsState) => ({
          ...state,
          saveCurrentScale: val,
        })),
      scale: initialTopToolsState.scale,
      setScale: (val: number) =>
        set((state: TopToolsState) => ({
          ...state,
          scale: val,
        })),
      activeOperation: initialTopToolsState.activeOperation,
      setActiveOperation: (val: string) =>
        set((state: TopToolsState) => ({
          ...state,
          activeOperation: val,
        })),
      showObjectList: initialTopToolsState.showObjectList,
      setShowObjectList: (val: boolean) =>
        set((state: TopToolsState) => ({ ...state, showObjectList: val })),
      showDescList: false,
      setShowDescList: (val: boolean) =>
        set((state: TopToolsState) => ({ ...state, showDescList: val })),
      showGroupList: initialTopToolsState.showGroupList,
      setShowGroupList: (val: boolean) =>
        set((state: TopToolsState) => ({ ...state, showGroupList: val })),
      showTaskList: initialTopToolsState.showTaskList,
      setShowTaskList: (val: boolean) =>
        set((state: TopToolsState) => ({ ...state, showTaskList: val })),
      showMultiFrame: initialTopToolsState.showMultiFrame,
      setShowMultiFrame: (val: boolean) =>
        set((state: TopToolsState) => ({ ...state, showMultiFrame: val })),
      currentTimeKey: initialTopToolsState.currentTimeKey,
      setCurrentTimeKey: (val) =>
        set((state: TopToolsState) => ({ ...state, currentTimeKey: val })),
      subAttrPresetShow: initialTopToolsState.subAttrPresetShow,
      setSubAttrPresetShow: (val) =>
        set((state: TopToolsState) => ({ ...state, subAttrPresetShow: val })),
      subAttributes: initialTopToolsState.subAttributes,
      setsubAttributes: (key, val) =>
        set((state: TopToolsState) => ({
          ...state,
          subAttributes: {
            ...state.subAttributes,
            [key]: safeClone(val),
          },
        })),
      objectOperations: initialTopToolsState.objectOperations,
      setObjectOperations: (val) =>
        set((state: TopToolsState) => ({ ...state, objectOperations: val })),
      needBackup: false,
      setNeedBackup: (val) =>
        set((state: TopToolsState) => ({ ...state, needBackup: val })),
      checkSize: 5,
      setCheckSize: (v) => set((state) => ({ ...state, checkSize: v })),
    }),
    {
      name: "top-tools",
    }
  )
)