import { ref } from 'vue'
import { autoSetModeCallback, createTemploraryID } from './sys'
import { 
  fetchGuides, 
  postAddGuide, 
  postDeleteGuide,
  postUpdateGuide,
  uploadFile,
} from '@/api'
import { 
  togetherCallback,
  deleteStoreItem, 
  addStoreItem, 
  updateStoreItem, 
  saveStoreItems,
  recoverStoreItems
} from '@/utils'

import {
  getGuidePaths, 
  guidePaths,
  recoverGuidePaths,
  backupGuidePaths,
  saveGuidePaths,
  initialGuidePathsByGuide
} from './guide-path'

import type { Guide as SGuide } from '@/api'
import { fuseModels } from './fuse-model'
import { custom } from '@/env'

export type Guide = LocalMode<SGuide, 'cover'>
export type Guides = Guide[]

export const guides = ref<Guides>([])

export const createGuide = (guide: Partial<Guide> = {}): Guide => ({
  id: createTemploraryID(),
  title: `路径${guides.value.length + 1}`,
  cover: '',
  ...guide
})

let bcGuides: Guides = []
export const getBackupGuides = () => bcGuides
export const backupGuides = () => {
  bcGuides = guides.value.map(guide => ({...guide }))
}

export const transformGuide = async (guide: Guide): Promise<SGuide> => {
  const guideCover = await uploadFile(guide.cover)
  return { ...guide, cover: guideCover }
}

export const addGuide = addStoreItem(guides, async (guide) => {
  const paths = getGuidePaths(guide)
  const recoveryContent = JSON.stringify(fuseModels.value.map(item => ({
    ...item,
    viewShow: custom.showModelsMap.get(item)
  })))
  guide.recoveryContent = recoveryContent
  const newGuide = await postAddGuide(guide)
  paths.forEach(path => path.guideId = newGuide.id)
  return newGuide
}, transformGuide)

export const deleteGuide = deleteStoreItem(guides, async guide => {
  const paths = getGuidePaths(guide)
  await postDeleteGuide(guide.id)
  guidePaths.value = guidePaths.value.filter(path => !paths.includes(path))
})

export const initialGuides = async () => {
  guides.value = await fetchGuides()
  await Promise.all(guides.value.map(initialGuidePathsByGuide))
  backupGuides()
}

export const recoverGuides = recoverStoreItems(guides, getBackupGuides)
export const updateGuide = updateStoreItem(guides, postUpdateGuide, transformGuide)
export const saveGuides = saveStoreItems(
  guides,
  getBackupGuides,
  {
    add: addGuide,
    update: updateGuide,
    delete: deleteGuide,
  }
)
export const autoSaveGuides = autoSetModeCallback([guides, guidePaths], {
  backup: togetherCallback([backupGuides, backupGuidePaths]),
  recovery: togetherCallback([recoverGuides, recoverGuidePaths]),
  save: async () => {
    await saveGuides()
    await saveGuidePaths()
  },
})