import { defineStore } from 'pinia'
import { ref } from 'vue'
import { ElMessage } from 'element-plus'
import type { BusinessType, PageResult } from '@/types/api'
import type { Case } from '@/types/business/cases'
import type {
  Address,
  ChangePasswordParams,
  Feedback,
  FavoritesQuery,
  HelpFaqGroup,
  ListQuery,
  Profile,
  Qualification,
  QualificationInput,
} from '@/types/business/profile'
import {
  bindEmail,
  bindPhone,
  changePassword,
  createAddress,
  createQualification,
  deleteAccount as deleteAccountApi,
  deleteAddress,
  deleteQualification,
  getAddresses,
  getCaseCounts,
  getFavorites,
  getHelpFaqs,
  getProfile,
  getQualifications,
  setDefaultAddress,
  submitFeedback as submitFeedbackApi,
  unbindEmail,
  updateAddress,
  updateNickname,
  updateQualification,
  verifyIdentity,
} from '@/api/profile'
import { storage } from '@/utils/storage'

function createDefaultAddressQuery(): ListQuery {
  return { page: 1, pageSize: 6 }
}

function createDefaultQualificationQuery(): ListQuery {
  return { page: 1, pageSize: 6 }
}

function createDefaultFavoritesQuery(): FavoritesQuery {
  return { page: 1, pageSize: 8, keyword: '', category: 'all' }
}

export const useProfileStore = defineStore('profile', () => {
  const profile = ref<Profile | null>(null)

  async function fetchProfile(): Promise<void> {
    profile.value = await getProfile()
  }

  async function saveNickname(name: string): Promise<void> {
    profile.value = await updateNickname(name)
    ElMessage.success('昵称修改成功')
  }

  async function changePasswordAction(params: ChangePasswordParams): Promise<void> {
    await changePassword(params)
    profile.value = await getProfile()
    ElMessage.success('密码修改成功')
  }

  async function bindPhoneAction(phone: string, code: string): Promise<void> {
    profile.value = await bindPhone(phone, code)
    ElMessage.success('手机号绑定成功')
  }

  async function bindEmailAction(email: string, code: string): Promise<void> {
    profile.value = await bindEmail(email, code)
    ElMessage.success('邮箱绑定成功')
  }

  async function unbindEmailAction(): Promise<void> {
    profile.value = await unbindEmail()
    ElMessage.success('已取消邮箱绑定')
  }

  async function verifyIdentityAction(phone: string, code: string): Promise<void> {
    await verifyIdentity(phone, code)
  }

  async function deleteAccountAction(): Promise<void> {
    await deleteAccountApi()
    storage.remove('token')
    ElMessage.success('注销成功')
  }

  const addresses = ref<Address[]>([])
  const addressTotal = ref(0)
  const addressQuery = ref<ListQuery>(createDefaultAddressQuery())

  async function fetchAddresses(): Promise<void> {
    const result: PageResult<Address> = await getAddresses(addressQuery.value)
    addresses.value = result.list
    addressTotal.value = result.total
  }

  async function createAddressAction(input: Omit<Address, 'id' | 'isDefault'>): Promise<void> {
    await createAddress(input)
    ElMessage.success('新增地址成功')
    addressQuery.value = { ...addressQuery.value, page: 1 }
    await fetchAddresses()
  }

  async function updateAddressAction(id: string, input: Omit<Address, 'id' | 'isDefault'>): Promise<void> {
    await updateAddress(id, input)
    ElMessage.success('地址保存成功')
    await fetchAddresses()
  }

  async function deleteAddressAction(id: string): Promise<void> {
    await deleteAddress(id)
    ElMessage.success('地址删除成功')
    await fetchAddresses()
  }

  async function setDefaultAddressAction(id: string): Promise<void> {
    await setDefaultAddress(id)
    ElMessage.success('已设为默认地址')
    await fetchAddresses()
  }

  async function changeAddressPage(page: number): Promise<void> {
    addressQuery.value = { ...addressQuery.value, page }
    await fetchAddresses()
  }

  const favorites = ref<Case[]>([])
  const favoritesTotal = ref(0)
  const favoritesCounts = ref<Partial<Record<BusinessType, number>>>({})
  const favoritesQuery = ref<FavoritesQuery>(createDefaultFavoritesQuery())

  async function fetchFavorites(): Promise<void> {
    const result: PageResult<Case> = await getFavorites(favoritesQuery.value)
    favorites.value = result.list
    favoritesTotal.value = result.total
  }

  async function fetchFavoritesCounts(): Promise<void> {
    favoritesCounts.value = await getCaseCounts()
  }

  async function searchFavorites(patch: Partial<FavoritesQuery>): Promise<void> {
    favoritesQuery.value = { ...favoritesQuery.value, ...patch, page: 1 }
    await fetchFavorites()
  }

  async function resetFavorites(): Promise<void> {
    favoritesQuery.value = createDefaultFavoritesQuery()
    await fetchFavorites()
  }

  async function changeFavoritesPage(page: number): Promise<void> {
    favoritesQuery.value = { ...favoritesQuery.value, page }
    await fetchFavorites()
  }

  const qualifications = ref<Qualification[]>([])
  const qualificationTotal = ref(0)
  const qualificationQuery = ref<ListQuery>(createDefaultQualificationQuery())

  async function fetchQualifications(): Promise<void> {
    const result: PageResult<Qualification> = await getQualifications(qualificationQuery.value)
    qualifications.value = result.list
    qualificationTotal.value = result.total
  }

  async function createQualificationAction(input: QualificationInput): Promise<void> {
    await createQualification(input)
    ElMessage.success('资质提交成功')
    qualificationQuery.value = { ...qualificationQuery.value, page: 1 }
    await fetchQualifications()
  }

  async function updateQualificationAction(id: string, input: QualificationInput): Promise<void> {
    await updateQualification(id, input)
    ElMessage.success('资质保存成功')
    await fetchQualifications()
  }

  async function deleteQualificationAction(id: string): Promise<void> {
    await deleteQualification(id)
    ElMessage.success('资质删除成功')
    await fetchQualifications()
  }

  async function changeQualificationPage(page: number): Promise<void> {
    qualificationQuery.value = { ...qualificationQuery.value, page }
    await fetchQualifications()
  }

  async function submitFeedbackAction(feedback: Feedback): Promise<void> {
    await submitFeedbackApi(feedback)
  }

  const helpFaqs = ref<HelpFaqGroup[]>([])

  async function fetchHelpFaqs(): Promise<void> {
    helpFaqs.value = await getHelpFaqs()
  }

  return {
    profile,
    fetchProfile,
    saveNickname,
    changePassword: changePasswordAction,
    bindPhone: bindPhoneAction,
    bindEmail: bindEmailAction,
    unbindEmail: unbindEmailAction,
    verifyIdentity: verifyIdentityAction,
    deleteAccount: deleteAccountAction,
    addresses,
    addressTotal,
    addressQuery,
    fetchAddresses,
    createAddress: createAddressAction,
    updateAddress: updateAddressAction,
    deleteAddress: deleteAddressAction,
    setDefaultAddress: setDefaultAddressAction,
    changeAddressPage,
    favorites,
    favoritesTotal,
    favoritesCounts,
    favoritesQuery,
    fetchFavorites,
    fetchFavoritesCounts,
    searchFavorites,
    resetFavorites,
    changeFavoritesPage,
    qualifications,
    qualificationTotal,
    qualificationQuery,
    fetchQualifications,
    createQualification: createQualificationAction,
    updateQualification: updateQualificationAction,
    deleteQualification: deleteQualificationAction,
    changeQualificationPage,
    submitFeedback: submitFeedbackAction,
    helpFaqs,
    fetchHelpFaqs,
  }
})