import XEUtils from 'xe-utils'


/**表格相关数据查询重置 */
export async function useTableQueryReload(tableRef:any){
    const params = tableRef.params
    if(params&&params.tableDataCache) params.tableDataCache=[] //重置表格数据缓存
    if(params&&params.filterNameRef) params.filterNameRef='' //重置表内搜索内容
    if(!XEUtils.isUndefined(tableRef.proxyConfig)){
        tableRef.commitProxy('reload') //重置表格相关数据
    }
    
}

/**
 * vxe代理请求参数处理
 * @param tableData 表所有数据
 * @param page 第几页
 * @param size 每页多少条
 * @returns 
 */
export function useQueryParamsHandle(queryFrom:{},page: any, sorts:any, filters:any){
    const queryParams: any = Object.assign({}, queryFrom)
    // 处理分页条件
    if (page) {
        queryParams.page = page.currentPage
        queryParams.size = page.pageSize
    }
    // 处理排序条件
    const firstSort = sorts[0]
    if (firstSort) {
        queryParams.sort = firstSort.field
        queryParams.order = firstSort.order
    }
    // 处理筛选条件
    filters.forEach(({ field, values }) => {
        queryParams[field] = values.join(',')
    })
    return queryParams
}

/**
 * 数据过滤
 * @param $table 表格引用
 * @param tableData 需要过滤的数据
 * @param filterEvent 过滤成功事件
 * @param resetEvent 重置过滤数据事件
 * @returns 
 */
function dataFilter($table:any,tableData:[],filterEvent:undefined,resetEvent:undefined){
    let tableParams=$table.params
    const filterVal = XEUtils.toValueString(tableParams.filterNameRef).trim().toLowerCase()
    if (filterVal) {
        let searchProps=tableParams.searchProps
        /**如需要检索的key不存在，则从表格对象中获取全部列字段名 */
        if(XEUtils.isUndefined(searchProps)||searchProps.length==0){
            searchProps=$table.getTableColumn().visibleColumn.map(function(vcolumn) { 
                return vcolumn.field; 
            });
        }
        let options={children: (XEUtils.isUndefined(tableParams.children)||!tableParams.children)?'no':''}
        const filterData = XEUtils.searchTree(tableData, item => searchProps.some(key => String(item[key]).toLowerCase().indexOf(filterVal) > -1), options)
        if(!XEUtils.isUndefined(filterEvent)&&'function'===typeof filterEvent){
            filterEvent(filterData)
        }
        return filterData
    }else {
        if(!XEUtils.isUndefined(resetEvent)&&'function'===typeof resetEvent){
            resetEvent(tableData)
        }
        return tableData
    }
}


/**
 * VxeTable表内检索
 * @param tableRef 表格对象
 */
export function useInVxeTableSearch($table:any){
    let tableParams=$table.params
    const filterVal = XEUtils.toValueString(tableParams.filterNameRef).trim().toLowerCase()
    if (filterVal) {
        let searchProps=tableParams.searchProps
        /**如需要检索的key不存在，则从表格对象中获取全部列字段名 */
        if(XEUtils.isUndefined(searchProps)||searchProps.length==0){
            searchProps=$table.getTableColumn().visibleColumn.map(function(vcolumn) { 
                return vcolumn.field; 
            });
        }
        let options={children: (XEUtils.isUndefined(tableParams.children)||!tableParams.children)?'no':''}
        const filterData = XEUtils.searchTree(tableParams.tableDataCache, item => searchProps.some(key => String(item[key]).toLowerCase().indexOf(filterVal) > -1), options)
        return filterData
    }else {
        return tableParams.tableDataCache
    }
}

/**
 * VxeGrid表内检索
 * 服务端分页(params.clientPage不配置或者配置为false)，不会修改当前分页数据
 * @param tableRef 表格对象
 */
export function useInVxeGridSearch(tableRef:any){
    const $table = tableRef

    if(!$table) {
        console.error('表格对象tableRef不存在');
        return false
    }
    if(!$table.params) {
        console.error('自定义参数配置params不存在');
        return false
    }
    let tableParams=$table.params
    /**客户端分页并且使用了代理配置，直接重新加载表格,通过useQueryAndClientPaging方法执行筛选操作 */
    if(tableParams.clientPage&&!XEUtils.isUndefined($table.proxyConfig)){
        $table.commitProxy('reload')
        return;
    }
    let tableData=[] //默认获取表格data中信息
    if(!XEUtils.isUndefined($table.data)){
        $table.data.forEach(function(o) { 
            tableData.push(o)
        });
    }
    if(!XEUtils.isUndefined($table.getProxyInfo())&&null!=$table.getProxyInfo())
        tableData=$table.getProxyInfo().data //从表格代理信息中获取当前全量数据
    /**如tableDataRef不存在，则从表格对象中初始化全量数据-----已从表格代理信息中获取当前全量数据，该逻辑暂不使用*/
    // let tableData=tableParams.tableDataCache //待处理数据
    // if(null==tableData||tableData.length==0){
    //     let visibleData=$table.getTableData().visibleData
    //     tableData=new Array()
    //     visibleData.forEach(function(v,k) { 
    //         tableData.push(v)
    //         v.children.forEach(function(cv,ck) { 
    //             tableData.push(cv)
    //         });
    //     });
    //     tableParams.tableDataCache=tableData
    // }
    dataFilter($table,tableData,
        function(filterData){
            $table.loadData(filterData)
            if(tableParams.allTreeExpand){
                // 搜索之后默认展开所有子节点
                nextTick(() => {
                    $table.setAllTreeExpand(true)
                })
            }
        },function(resetData){
            $table.loadData(resetData)
        }
    )
}

/**
 * 查询数据，并由客户端分页
 * @param tableRef 表格对象
 * @param page 分页信息
 * @param sorts 排序信息
 * @param requestMethod 执行查询的方法
 * @returns 
 */
export async function useQueryAndClientPaging(tableRef:any,page: any, sorts:any, requestMethod:any){
    const $table = tableRef.value
    if(!$table) {
        console.error('表格对象tableRef不存在');
        return false
    }
    if(!$table.params) {
        console.error('自定义参数配置params不存在');
        return false
    }
    if(!$table.params.clientPage){
        console.error('自定义参数配置params.clientPage应该设置为true');
        return false
    }
    let cdata=$table.params.tableDataCache
    /**缓存中不存在数据，则发起请求，并初始化缓存 */
    if(cdata.length==0){
        let dataPromise= await requestMethod() 
        $table.params.tableDataCache=dataPromise
        cdata=dataPromise
    }
    /**排序*/
    cdata=XEUtils.orderBy(cdata, sorts.map((sort:any) => [sort.field, sort.order]))
    /**如表内搜索存在关键字，则首先过滤数据 */
    cdata=dataFilter($table,cdata)
    return new Promise((resolve) => {
        resolve({
        total:cdata.length,
        data:cdata.slice((page.currentPage - 1) * page.pageSize, page.currentPage * page.pageSize)
        });
    });
}








