import store from '@/store'

export function usePermission(): any {
    const get = () => {
        const permission = store.state.userInfo.permissions
        return permission
    }
    const has = str => {
        const arr = get()
        if (str === '' || str === undefined || str === 'undefined') {
            return true
        }
        return arr.includes(str)
    }
    const hasPermission = (roles = [], route) => {
        if (route.meta && route.meta.roles && route.meta.roles.page) {
            return roles.some(role => route.meta.roles.page === role)
        } else {
            return true
        }
    }
    const p_hasPermission = (roles = [], route) => {
        return new Promise(resolve => {
            if (route.meta && route.meta.roles && route.meta.roles.page) {
                resolve(roles.some(role => route.meta.roles.page === role))
            } else {
                resolve(true)
            }
        })
    }
    const filterAsyncRoutes = (routes, roles) => {
        if (!roles.length) {
            return routes
        }
        const res: any = []
        routes.forEach(route => {
            const tmp = { ...route }
            if (hasPermission(roles, tmp)) {
                if (tmp.children) {
                    tmp.children = filterAsyncRoutes(tmp.children, roles)
                }
                res.push(tmp)
            }
        })
        return res
    }

    const findDepend = (arr, result1) => {
        const result: any = result1 || []
        arr.map(item => {
            if (arr.children && arr.children.length) {
                findDepend(arr.children, result)
            } else {
                if (item.meta && !item.meta.depend) {
                    result.push(item)
                }
            }
        })
        return result
    }

    const childRoleItem = (arr, roles, callback?) => {
        let result = {}
        const newarr = findDepend(arr, [])
        let firstFlag = true
        newarr.some((item, index) => {
            if (item.meta) {
                p_hasPermission(roles, item).then(res => {
                    if (res && firstFlag) {
                        firstFlag = false
                        result = newarr[index]
                        callback(result)
                        return true
                    }
                })
            }
        })
    }

    const findRoleItem = (currentRouterRoot, reqUri, arr, roles, currentUrl) => {
        return new Promise(resolve => {
            let firstRoleItem: any = {}
            const allRouters = JSON.parse(JSON.stringify(arr))
            let someFlag = true
            let currentRoute = currentUrl.split('#')[1]
            currentRoute = currentRoute.includes('?') ? currentRoute.split('?')[0] : currentRoute
            if(currentRoute !== reqUri.slice(11)) {
                return
            }
            allRouters.some((item, index) => {
                if (item.meta.hidden) {
                    delete allRouters[index]
                    return
                }
                if (
                    item.name &&
                    item.name.includes(currentRouterRoot + '-')
                ) {
                    p_hasPermission(roles, item).then(res => {
                        if (res && someFlag) {
                            someFlag = false
                            firstRoleItem = allRouters[index]
                        }
                    })
                }
            })

            setTimeout(() => {
                if (
                    firstRoleItem.meta &&
                    firstRoleItem.meta.roles &&
                    firstRoleItem.meta.roles.page
                ) {
                    childRoleItem(
                        firstRoleItem.children,
                        roles,
                        item => {
                            if (item.children && item.children.length) {
                                let someFlag1 = true
                                let firstRoleItem1: any = {}
                                item.children.some((ele, index) => {
                                    if (ele.meta.hidden) {
                                        delete item.children[index]
                                        return
                                    }
                                    if (
                                        ele.name &&
                                        ele.name.includes(
                                            currentRouterRoot + '-'
                                        )
                                    ) {
                                        p_hasPermission(roles, ele)
                                            .then(res => {
                                                if (res && someFlag1) {
                                                    someFlag1 = false
                                                    firstRoleItem1 =
                                                        item.children[index]
                                                }
                                            })
                                    }
                                })
                                setTimeout(() => {
                                    if (
                                        firstRoleItem1.meta &&
                                        firstRoleItem1.meta.roles &&
                                        firstRoleItem1.meta.roles.page &&
                                        firstRoleItem1.children &&
                                        firstRoleItem1.children.length
                                    ) {
                                        childRoleItem(
                                            firstRoleItem1.children,
                                            roles,
                                            item1 => {
                                                resolve(item1)
                                            }
                                        )
                                    } else {
                                        if (
                                            Object.keys(firstRoleItem1)
                                                .length > 0
                                        ) {
                                            resolve(firstRoleItem1)
                                        } else {
                                            resolve({
                                                path: reqUri.slice(
                                                    11
                                                ),
                                            })
                                        }
                                    }
                                }, 100)
                            } else {
                                resolve(item)
                            }
                        }
                    )
                } else {
                    if (Object.keys(firstRoleItem).length > 0) {
                        resolve(firstRoleItem)
                    } else {
                        resolve({
                            path: reqUri.slice(11),
                        })
                    }
                }
            }, 100)
        })
    }

    return { get, has, hasPermission, filterAsyncRoutes, p_hasPermission, findRoleItem }
}