import {
    defineStore
} from 'pinia';
import {
    reactive,
    ref,
} from 'vue'
import {
    createRequest
} from "../utils/request";

//  静态树 O(1) 超快查询！！！！！
let IndustryMap = null
//  构建索引
function buildIndex(tree) {
    const map = new Map();

    function traverse(nodes) {
        for (const node of nodes) {
            map.set(node.id, node);
            if (node.children && node.children.length) {
                traverse(node.children);
            }
        }
    }
    traverse(tree);
    return map;
}
const useDictStore = defineStore("dict", () => {
    // 定义状态
    const complete = ref(false)
    const state = reactive({
        education: [],
        experience: [],
        area: [],
        scale: [],
        isPublish: [],
        sex: [],
        affiliation: [],
        industry: []
    })
    // political_affiliation
    const getDictData = async (dictType, dictName) => {
        try {
            if (dictType && dictName) {
                return getDictSelectOption(dictType).then((data) => {
                    state[dictName] = data
                    return data
                })
            }
            const [education, experience, area, scale, sex, affiliation] = await Promise.all([
                getDictSelectOption('education'),
                getDictSelectOption('experience'),
                getDictSelectOption('area', true),
                getDictSelectOption('scale'),
                getDictSelectOption('app_sex'),
                getDictSelectOption('political_affiliation'),
            ]);

            state.education = education;
            state.experience = experience;
            state.area = area;
            state.scale = scale;
            state.sex = sex;
            state.affiliation = affiliation;
            complete.value = true
            getIndustryDict() // 获取行业
        } catch (error) {
            console.error('Error fetching dictionary data:', error);
        }
    };

    async function getIndustryDict() {
        if (state.industry.length) return
        const resp = await createRequest(`/app/common/industry/treeselect`);
        if (resp.code === 200 && resp.data) {
            state.industry = resp.data
            IndustryMap = buildIndex(resp.data);
        }
        return [];
    }

    function industryLabel(dictType, value) {
        switch (dictType) {
            case 'industry':
                if (!IndustryMap) return
                const data = IndustryMap.get(Number(value))?.label || ''
                return data
        }
        return null
    }

    function dictLabel(dictType, value) {
        if (state[dictType]) {
            for (let i = 0; i < state[dictType].length; i++) {
                let element = state[dictType][i];
                if (element.value === value) {
                    return element.label
                }
            }
        }
        return ''
    }

    function oneDictData(dictType, value) {
        if (!value) {
            return state[dictType]
        }
        if (state[dictType]) {
            for (let i = 0; i < state[dictType].length; i++) {
                let element = state[dictType][i];
                if (element.value === value) {
                    return element
                }
            }
        }
        return null
    }

    function getTransformChildren(dictType, title = '', key = '') {
        if (dictType) {
            return {
                label: title,
                key: key || dictType,
                options: state[dictType],
            }
        }
        return null
    }

    async function getDictSelectOption(dictType, isDigital) {
        const resp = await createRequest(`/app/common/dict/${dictType}`);
        if (resp.code === 200 && resp.data) {
            const options = resp.data.map((item) => {
                return {
                    text: item.dictLabel,
                    label: item.dictLabel,
                    value: isDigital ? Number(item.dictValue) : item.dictValue,
                    key: item.dictCode,
                    listClass: item.listClass,
                    status: item.listClass,
                };
            });
            return options;
        }
        return [];
    }

    async function getDictValueEnum(dictType, isDigital) {
        const resp = await createRequest(`/app/common/dict/${dictType}`);
        if (resp.code === 200 && resp.data) {
            const opts = {};
            resp.data.forEach((item) => {
                opts[item.dictValue] = {
                    text: item.dictLabel,
                    label: item.dictLabel,
                    value: isDigital ? Number(item.dictValue) : item.dictValue,
                    key: item.dictCode,
                    listClass: item.listClass,
                    status: item.listClass,
                };
            });
            return opts;
        } else {
            return {};
        }
    }

    // 导入
    return {
        getDictData,
        dictLabel,
        oneDictData,
        complete,
        getDictSelectOption,
        getTransformChildren,
        industryLabel
    }
})

export default useDictStore;