import { ref } from 'vue'
import { getCommonDictList } from '@/api/common'

const DICT_CACHE_KEY = 'system_dict_data'

export function useGetDictList() {
    const dictData = ref([])
    const uniqueTypes = ref([])
    const optionsByType = ref({})

    /**
     * 加载字典数据
     * @param {boolean} forceRefresh - 是否强制刷新缓存
     * @returns {Promise<{uniqueTypes: Array, optionsByType: Object}>}
     */
    const loadDictData = async (forceRefresh = false) => {
        try {
            // 强制刷新时清除缓存
            if (forceRefresh) {
                clearDictCache()
            }

            // 尝试从缓存读取
            const cached = sessionStorage.getItem(DICT_CACHE_KEY)
            if (cached && !forceRefresh) {
                const parsedData = JSON.parse(cached)
                dictData.value = parsedData || []
            } else {
                // 从API获取数据
                const res = await getCommonDictList()
                dictData.value = res.data || []
                sessionStorage.setItem(DICT_CACHE_KEY, JSON.stringify(res.data))
            }


            // 处理数据
            const { uniqueTypes: ut, optionsByType: obt } = processDictData(dictData.value)
            uniqueTypes.value = ut
            optionsByType.value = obt

            return { uniqueTypes: ut, optionsByType: obt }
        } catch (error) {
            console.error('加载字典数据失败:', error)
            dictData.value = []
            uniqueTypes.value = []
            optionsByType.value = {}
            return { uniqueTypes: [], optionsByType: {} }
        }
    }

    /**
     * 处理字典数据
     * @param {Array} data - 字典数据
     * @returns {{uniqueTypes: Array, optionsByType: Object}}
     */
    const processDictData = (data) => {
        const result = data.reduce(
            (acc, item) => {
                // 收集唯一的 typeCode + typeName
                const typeKey = `${item.typeCode}|${item.typeName}`
                if (!acc.uniqueTypeKeys.has(typeKey)) {
                    acc.uniqueTypes.push({
                        typeCode: item.typeCode,
                        typeName: item.typeName,
                    })
                    acc.uniqueTypeKeys.add(typeKey)
                }

                // 按 typeCode 分组生成 options
                if (!acc.optionsByType[item.typeCode]) {
                    acc.optionsByType[item.typeCode] = []
                }
                acc.optionsByType[item.typeCode].push({
                    value: item.dictionaryCode,
                    label: item.dictionaryName,
                })

                return acc
            },
            {
                uniqueTypes: [],
                uniqueTypeKeys: new Set(),
                optionsByType: {},
            }
        )

        return {
            uniqueTypes: result.uniqueTypes,
            optionsByType: result.optionsByType,
        }
    }

    /**
     * 获取指定类型的选项
     * @param {string} typeCode - 字典类型代码
     * @param {boolean} [filterEnabled=true] - 是否过滤未启用的项
     * @returns {Array<{value: string|number, label: string}>}
     */
    const getOptions = (typeCode, filterEnabled = true) => {
        if (!dictData.value.length) {
            console.warn('字典数据未加载，请先调用 loadDictData')
            return []
        }

        return dictData.value
            .filter(item => item.typeCode === typeCode && (!filterEnabled || item.enabled === 1))
            .sort((a, b) => a.sort - b.sort)
            .map(item => ({
                label: item.dictionaryName,
                value: isNaN(Number(item.dictionaryCode))
                    ? item.dictionaryCode
                    : Number(item.dictionaryCode),
            }))
    }

    /**
     * 获取单个字典匹配下标的名称
     * @param {string} typeCode - 字典类型代码
     * @param {string | number} dictionaryCode - 字典下标值
     * @returns 
     */
    function getDictionaryName(typeCode, dictionaryCode) {
        if (!dictData.value.length) {
            console.warn('字典数据未加载，请先调用 loadDictData')
            return []
        }

        const item = dictData.value.find(
            entry =>
                entry.typeCode === typeCode &&
                entry.dictionaryCode === String(dictionaryCode)
        );
        return item ? item.dictionaryName : '暂无数据';
    }

    /**
     * 清除字典缓存
     */
    const clearDictCache = () => {
        sessionStorage.removeItem(DICT_CACHE_KEY)
        dictData.value = []
        uniqueTypes.value = []
        optionsByType.value = {}
    }

    return {
        dictData, // 字典原数据
        uniqueTypes, // 唯一的字典类型集合
        optionsByType, // 按类型分组的选项
        loadDictData, // 加载字典数据
        clearDictCache, // 清除缓存
        getOptions, // 获取指定类型的选项
        getDictionaryName, //获取单个字典匹配下标的名称
    }
}