import { ref, watch, computed, nextTick } from 'vue'
import useSchool from '@/hooks/useSchool'
import { listAllSubject } from '@/api/dz/subject'

/**
 * 通用的省份-考生类型-科目联动 Hook
 * @param {Object} options - 配置选项
 * @param {Boolean} options.autoLoadArea - 是否自动加载省份列表，默认 true
 * @param {Boolean} options.loadExamType - 是否加载考生类型，默认 true
 * @param {Boolean} options.onlyVHS - 是否只在考生类型为 VHS 时加载科目，默认 false
 * @returns {Object} 返回响应式数据和方法
 */
export function useProvinceExamTypeSubject(options = {}) {
  const {
    autoLoadArea = true,
    loadExamType = true,
    onlyVHS = false
  } = options

  // 使用 useSchool hook 获取省份和考生类型相关功能
  const {
    area,
    getAreaList,
    examTypeList,
    selectedExamType,
    getExamTypeList,
    reset: resetSchool
  } = useSchool({ 
    autoLoad: autoLoadArea, 
    loadExamType: loadExamType 
  })

  // 科目相关
  const subjectList = ref([])
  const selectedSubjectId = ref(null)
  
  // 初始化标志，用于标识是否正在初始化数据
  const isInitializing = ref(false)

  // 计算 location（从 area.selectedItem 获取）
  const location = computed(() => {
    return area.selectedItem?.shortName || area.selectedItem?.areaName?.replace('省', '') || null
  })

  // 监听省份变化，重新加载考生类型
  watch(() => area.selected, async (newVal) => {
    // 如果正在初始化，不清空考生类型
    if (isInitializing.value) {
      return
    }
    
    if (newVal && loadExamType) {
      // 省份变化时，重新加载考生类型列表
      await getExamTypeList()
      // 清空已选择的考生类型和科目
      selectedExamType.value = null
      selectedSubjectId.value = null
      subjectList.value = []
    } else if (!newVal) {
      // 清空省份时，清空考生类型和科目
      selectedExamType.value = null
      selectedSubjectId.value = null
      subjectList.value = []
    }
  })

  // 监听考生类型和省份变化，加载科目列表
  watch([selectedExamType, location], async ([examType, loc], [oldExamType, oldLocation]) => {
    // 避免初始化时执行
    if (oldExamType === undefined && oldLocation === undefined) {
      return
    }

    // 只有 location 与 examType 都有值时才调用
    if (examType && loc) {
      // 如果设置了 onlyVHS，只有考生类型为 VHS 时才加载
      if (onlyVHS && examType !== 'VHS') {
        subjectList.value = []
        selectedSubjectId.value = null
        return
      }
      
      // 加载科目列表
      await loadSubjectList(loc, examType)
    } else {
      // 如果 location 或 examType 为空，清空科目列表
      subjectList.value = []
      selectedSubjectId.value = null
    }
  })

  /**
   * 加载科目列表
   * @param {String} loc - 省份名称
   * @param {String} examType - 考生类型
   */
  const loadSubjectList = async (loc, examType) => {
    try {
      const res = await listAllSubject({
        locations: loc,
        examTypes: examType
      })
      
      // 转换数据格式
      subjectList.value = (res.data || []).map(item => ({
        subjectId: item.subjectId,
        subjectName: item.subjectName,
        locations: item.locations,
        examTypes: item.examTypes
      }))
      
      // 如果当前选中的科目不在新列表中，清空选择
      if (selectedSubjectId.value) {
        const exists = subjectList.value.some(s => s.subjectId === selectedSubjectId.value)
        if (!exists) {
          selectedSubjectId.value = null
        }
      }
    } catch (error) {
      console.error('加载科目列表失败:', error)
      subjectList.value = []
      selectedSubjectId.value = null
    }
  }

  /**
   * 重置所有数据
   */
  const reset = () => {
    resetSchool()
    subjectList.value = []
    selectedSubjectId.value = null
  }

  /**
   * 初始化数据（用于编辑场景）
   * @param {Object} data - 初始数据
   * @param {String} data.location - 省份名称
   * @param {String} data.examType - 考生类型
   * @param {Number} data.subjectId - 科目ID
   */
  const initData = async (data = {}) => {
    // 设置初始化标志，防止 watch 清空数据
    isInitializing.value = true
    
    try {
      // 保存要设置的考生类型值
      const examTypeToSet = data.examType
      
      // 如果有 location，设置省份
      if (data.location) {
        const areaList = await getAreaList()
        // 查找匹配的省份（支持带"省"或不带"省"）
        const targetArea = areaList.find(item => {
          const areaName = item.areaName?.replace('省', '')
          return areaName === data.location || item.areaName === data.location + '省'
        })
        if (targetArea) {
          area.list = areaList
          area.selected = targetArea.areaId
          area.selectedItem = targetArea
          
          // 等待考生类型列表加载完成（如果 loadExamType 为 true）
          if (loadExamType) {
            await getExamTypeList()
            // 等待一下，确保 examTypeList 已经更新
            await nextTick()
          }
        }
      }

      // 设置考生类型（在考生类型列表加载完成后设置）
      if (examTypeToSet) {
        selectedExamType.value = examTypeToSet
        // 等待一下，确保 watch 执行完成
        await nextTick()
      }

      // 设置科目ID（需要在科目列表加载完成后设置）
      if (data.subjectId) {
        // 等待科目列表加载（最多等待3秒）
        let resolved = false
        await new Promise((resolve) => {
          const timeout = setTimeout(() => {
            if (!resolved) {
              resolved = true
              resolve()
            }
          }, 3000)
          
          const unwatch = watch(subjectList, (newList) => {
            if (newList.length > 0 && !resolved) {
              resolved = true
              clearTimeout(timeout)
              selectedSubjectId.value = Number(data.subjectId)
              unwatch()
              resolve()
            }
          }, { immediate: true })
        })
      }
    } finally {
      // 初始化完成，清除标志
      isInitializing.value = false
    }
  }

  return {
    // 省份相关
    area,
    getAreaList,
    location,
    
    // 考生类型相关
    examTypeList,
    selectedExamType,
    getExamTypeList,
    
    // 科目相关
    subjectList,
    selectedSubjectId,
    loadSubjectList,
    
    // 方法
    reset,
    initData
  }
}

export default useProvinceExamTypeSubject

