ToDoList/WebUI/src/stores/useAnniversaryStore.ts

import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { anniversaryApi } from '@/api/anniversaries'
import type { Anniversary, AnniversaryFormData, AnniversaryCategory, AnniversaryCategoryFormData } from '@/api/types'

export const useAnniversaryStore = defineStore('anniversary', () => {
  const anniversaries = ref<Anniversary[]>([])
  const categories = ref<AnniversaryCategory[]>([])
  const loading = ref(false)
  const activeCategoryId = ref<number | null>(null)

  const filteredAnniversaries = computed(() => {
    if (activeCategoryId.value === null) {
      return anniversaries.value
    }
    return anniversaries.value.filter(a => a.category_id === activeCategoryId.value)
  })

  const upcomingAnniversaries = computed(() =>
    filteredAnniversaries.value.filter(a => a.days_until !== null && a.days_until! >= 0)
  )

  const pastAnniversaries = computed(() =>
    filteredAnniversaries.value.filter(a => a.days_until === null || a.days_until! < 0)
  )

  const todayAnniversaries = computed(() =>
    filteredAnniversaries.value.filter(a => a.days_until === 0)
  )

  const remindAnniversaries = computed(() =>
    filteredAnniversaries.value.filter(a =>
      a.days_until !== null && a.days_until! >= 0 && a.days_until! <= a.remind_days_before
    )
  )

  // ============ 纪念日操作 ============

  async function fetchAnniversaries() {
    loading.value = true
    try {
      const params = activeCategoryId.value !== null
        ? { category_id: activeCategoryId.value }
        : undefined
      anniversaries.value = await anniversaryApi.getAnniversaries(params)
    } catch (error) {
      console.error('获取纪念日列表失败:', error)
    } finally {
      loading.value = false
    }
  }

  async function createAnniversary(data: AnniversaryFormData): Promise<Anniversary | null> {
    try {
      const newAnniversary = await anniversaryApi.createAnniversary(data)
      anniversaries.value.unshift(newAnniversary)
      reSort()
      return newAnniversary
    } catch (error) {
      console.error('创建纪念日失败:', error)
      return null
    }
  }

  async function updateAnniversary(id: number, data: Partial<AnniversaryFormData>): Promise<Anniversary | null> {
    try {
      const updated = await anniversaryApi.updateAnniversary(id, data)
      const index = anniversaries.value.findIndex(a => a.id === id)
      if (index !== -1) {
        anniversaries.value[index] = updated
      }
      reSort()
      return updated
    } catch (error) {
      console.error('更新纪念日失败:', error)
      return null
    }
  }

  async function deleteAnniversary(id: number): Promise<boolean> {
    try {
      await anniversaryApi.deleteAnniversary(id)
      anniversaries.value = anniversaries.value.filter(a => a.id !== id)
      return true
    } catch (error) {
      console.error('删除纪念日失败:', error)
      return false
    }
  }

  // ============ 分类操作 ============

  async function fetchCategories() {
    try {
      categories.value = await anniversaryApi.getCategories()
    } catch (error) {
      console.error('获取纪念日分类失败:', error)
    }
  }

  async function createCategory(data: AnniversaryCategoryFormData): Promise<AnniversaryCategory | null> {
    try {
      const newCat = await anniversaryApi.createCategory(data)
      categories.value.push(newCat)
      categories.value.sort((a, b) => a.sort_order - b.sort_order)
      return newCat
    } catch (error) {
      console.error('创建纪念日分类失败:', error)
      return null
    }
  }

  async function updateCategory(id: number, data: Partial<AnniversaryCategoryFormData>): Promise<AnniversaryCategory | null> {
    try {
      const updated = await anniversaryApi.updateCategory(id, data)
      const index = categories.value.findIndex(c => c.id === id)
      if (index !== -1) {
        categories.value[index] = updated
      }
      categories.value.sort((a, b) => a.sort_order - b.sort_order)
      return updated
    } catch (error) {
      console.error('更新纪念日分类失败:', error)
      return null
    }
  }

  async function deleteCategory(id: number): Promise<boolean> {
    try {
      await anniversaryApi.deleteCategory(id)
      categories.value = categories.value.filter(c => c.id !== id)
      if (activeCategoryId.value === id) {
        activeCategoryId.value = null
      }
      return true
    } catch (error) {
      console.error('删除纪念日分类失败:', error)
      return false
    }
  }

  function setFilter(categoryId: number | null) {
    activeCategoryId.value = categoryId
  }

  function reSort() {
    anniversaries.value.sort((a, b) => {
      const aUpcoming = a.days_until !== null && a.days_until >= 0 ? 0 : 1
      const bUpcoming = b.days_until !== null && b.days_until >= 0 ? 0 : 1
      if (aUpcoming !== bUpcoming) return aUpcoming - bUpcoming
      return (a.days_until ?? 9999) - (b.days_until ?? 9999)
    })
  }

  async function init() {
    await Promise.all([fetchAnniversaries(), fetchCategories()])
  }

  return {
    anniversaries,
    categories,
    loading,
    activeCategoryId,
    filteredAnniversaries,
    upcomingAnniversaries,
    pastAnniversaries,
    todayAnniversaries,
    remindAnniversaries,
    fetchAnniversaries,
    createAnniversary,
    updateAnniversary,
    deleteAnniversary,
    fetchCategories,
    createCategory,
    updateCategory,
    deleteCategory,
    setFilter,
    init,
  }
})