import { message } from 'ant-design-vue'
import { cloneDeep, findIndex, isEmpty } from 'lodash-es'
import { defineStore } from 'pinia'
import { getDictByType } from '@/apis/modules/common'
import router from '@/router'
import apis from '@/apis'
import useAppStore from './app'

const useDicsStore = defineStore('dics', {
    state: () => ({
        dictOptions: {},
        provinceOptions: [],
        orgTree: [],
    }),
    getters: {
        /**
         * 根据字典 key 获取选项列表
         * @param state
         * @returns {function(string): Array}
         */
        getDict: (state) => (key) => {
            return state.dictOptions[key] || []
        },

        /**
         * 根据字典 key 和值，获取对应的中文描述（introduction）
         * @param state
         * @returns {function(string, string): string}
         */
        getDictLabel: (state) => (key, value) => {
            const options = state.dictOptions[key] || []
            const item = options.find((opt) => opt.dval === value)
            return item ? item.introduction : '-'
        },

        /**
         * 判断某个字典是否存在
         */
        hasDict: (state) => (key) => {
            return !!state.dictOptions[key]
        },
    },
    mutations: {
        /**
         * 保存所有字典数据
         * @param state
         * @param payload {Object} 字典对象
         */
        SET_DICT_DATA(state, payload) {
            state.dictOptions = { ...payload }
        },

        /**
         * 清空字典数据
         * @param state
         */
        CLEAR_DICT_DATA(state) {
            state.dictOptions = {}
        },
    },

    actions: {
        // 初始加载省份
        async loadProvinces() {
            try {
                const response = await apis.common.getAreaList({ current: 1, pageSize: 100 })
                console.log('获取省份响应:', response)
                if (Array.isArray(response.data)) {
                    this.provinceOptions = response.data.map((province) => ({
                        ...province,
                        isLeaf: !province.hasChild, // 一定有子节点（市）
                    }))
                } else {
                    console.warn('获取省份失败:', response.data.message)
                }
            } catch (error) {
                console.error('请求省份数据失败:', error)
            }
        },
        /**
         * 从后端加载所有字典数据
         * @param commit
         * @returns {Promise<void>}
         */
        async loadAllDictData() {
            try {
                const res = await apis.dict
                    .getProjectList({
                        pageSize: 100,
                        current: 1,
                    })
                    .catch(() => {
                        throw new Error()
                    })
                if (res?.data) {
                    this.dictOptions = res.data
                    if (res.data.length > 0) {
                        const dictTypes = res.data.map((item) => item.code)
                        const requests = dictTypes.map((type) => getDictByType(type))
                        const results = await Promise.all(requests)
                        // 将结果按 type 存入 dictOptions
                        dictTypes.forEach((type, index) => {
                            this.dictOptions[type] = results[index].data || []
                        })
                        console.log('字典数据加载完成', this.dictOptions)
                    }
                }
            } catch (error) {
                console.error('加载字典数据失败：', error)
            }
        },
                /**
         * 将后端返回的树结构数据转换为 a-tree-select 所需格式
         * @param {Array} data - 原始数据
         * @returns {Array} 转换后的 [{ value, label, children }]
         */
        formatTreeData(data) {
            return data.map((item) => {
                const node = {
                    value: item.id,
                    label: item.name,
                    // disabled: item.disabled, // 可选：如果需要禁用某些节点
                }

                // 如果有 children，递归处理
                if (item.children && item.children.length > 0) {
                    node.children = this.formatTreeData(item.children)
                }

                return node
            })
        },
        async loadOrgTree() {
            try {
                const response = await apis.serviceMenu.getNodeList({ current: 1, pageSize: 100 })
                if (Array.isArray(response.data)) {
                    this.orgTree = this.formatTreeData(response.data)
                } else {
                    console.warn('获取省份失败:', response.data.message)
                }
            } catch (error) {
                console.error('请求省份数据失败:', error)
            }
        },

        /**
         * 可选：清空字典数据（登出时调用）
         */
        clearDictData({ commit }) {
            commit('CLEAR_DICT_DATA')
        },
    },
})

export default useDicsStore
