// 注：這里的 httpRequest 請根據(jù)自己項目而定，比如我的項目是uniapp，里面的http請求是 uni.request，若你的項目是 axios 或者 ajax，那就根據(jù)它們來對 BatchHttp 中的某些部分
import httpRequest from './httpRequest.js'

/**
 * 批量請求封裝
 */
export class BatchHttp {

    /** 
     * 構(gòu)造函數(shù) 
     * @param {Object} http - http請求對象（該http請求攔截器里切勿帶有任何有關(guān)ui的功能，比如加載對話框、彈窗提示框之類）,用于發(fā)起請求，該http請求對象必須滿足：返回一個包含取消請求函數(shù)的對象，因為在 this.cancelAll() 函數(shù)中會使用到
     * @param {string} [passFlagProp=null] - 用于識別是否忽略某些數(shù)據(jù)項的字段名（借此可實現(xiàn)“繼續(xù)上一次完成的批量請求”）；如：passFlagProp='url' 時，在執(zhí)行 exec 時，會過濾掉 items['url'] 不為空的數(shù)據(jù)，借此可以實現(xiàn)“繼續(xù)上一次完成的批量請求”，避免每次都重復(fù)所有請求
     */ 
    constructor(http=httpRequest, passFlagProp=null) {
        /** @private @type {Object[]} 請求任務(wù)數(shù)組 */
        this.resTasks = []
        /** @private @type {Object} uni.request對象 */
        this.http = http
        /** @private @type {boolean} 取消請求標(biāo)志 */
        this.canceled = false
        /** @private @type {string|null} 識別跳過數(shù)據(jù)的屬性 */
        this.passFlagProp = passFlagProp
    }


    /**
     * 將數(shù)組拆分成多個 size 長度的小數(shù)組
     * 常用于批量處理控制并發(fā)等場景
     * @param {Array} array - 需要拆分的數(shù)組
     * @param {number} size - 每個小數(shù)組的長度
     * @returns {Array} - 拆分后的小數(shù)組組成的二維數(shù)組
    */
    #chunk(array, size) {
        const chunks = []
        let index = 0
    
        while(index < array.length) {
        chunks.push(array.slice(index, size + index))
        index += size;
        }
    
        return chunks
    }

    /** 
     * 單個數(shù)據(jù)項請求 
     * @private
     * @param {Object} reqOptions - 請求配置
     * @param {Object} item - 數(shù)據(jù)項 
     * @returns {Promise} 請求Promise
    */
    #singleRequest(reqOptions, item) {
        return new Promise((resolve, _reject) => {
            const task = this.http({
                url: reqOptions.url, 
                method: reqOptions.method || 'GET',
                data: reqOptions.data,
                success: res => {
                    resolve({sourceItem:item, res})
                }
            })
            this.resTasks.push(task)
        })
    }

    /**
     * 批量請求控制
     * @private
     * @async
     * @param {Object} options - 函數(shù)參數(shù)項
     * @param {Array} options.items - 數(shù)據(jù)項數(shù)組
     * @param {Object} options.reqOptions - 請求配置  
     * @param {number} [options.concurrentNum=10] - 并發(fā)數(shù)
     * @param {Function} [options.chunkCallback] - 分塊回調(diào) 
     * @returns {Promise}
    */
    async #batchRequest({items, reqOptions, concurrentNum = 10, chunkCallback=(ress)=>{}}) {
        const promiseArray = []
        let data = []
        const passFlagProp = this.passFlagProp
        if(!passFlagProp) {
            data = items
        } else {
            // 若設(shè)置獨(dú)立 passFlagProp 值，則篩選出對應(yīng)屬性值為空的數(shù)據(jù)（避免每次都重復(fù)請求所有數(shù)據(jù)，實現(xiàn)“繼續(xù)未完成的批量請求任務(wù)”）
            data = items.filter(d => !Object.hasOwnProperty.call(d, passFlagProp) || !d[passFlagProp])
        }
        // --
        if(data.length === 0) return

        data.forEach(item => {
            const requestPromise = this.#singleRequest(reqOptions, item)
            promiseArray.push(requestPromise)
        })

        const promiseChunks = this.#chunk(promiseArray, concurrentNum) // 切分成 n 個請求為一組

        for (let ck of promiseChunks) {
            // 若當(dāng)前處于取消請求狀態(tài)，則直接跳出
            if(this.canceled) break
            // 發(fā)起一組請求
            const ckRess = await Promise.all(ck) // 控制并發(fā)數(shù)
            chunkCallback(ckRess) // 每完成組請求，都進(jìn)行回調(diào)
        }
    }

    /**
     * 設(shè)置用于識別忽略數(shù)據(jù)項的字段名
     * （借此參數(shù)可實現(xiàn)“繼續(xù)上一次完成的批量請求”）；
     * 如：passFlagProp='url' 時，在執(zhí)行 exec 時，會過濾掉 items['url'] 不為空的數(shù)據(jù)，借此可以實現(xiàn)“繼續(xù)上一次完成的批量請求”，避免每次都重復(fù)所有請求
     * @param {string} val 
     */
    setPassFlagProp(val) {
        this.passFlagProp = val
    }

    /**
     * 執(zhí)行批量請求操作
     * @param {Object} options - 函數(shù)參數(shù)項
     * @param {Array} options.items - 數(shù)據(jù)項數(shù)組
     * @param {Object} options.reqOptions - 請求配置  
     * @param {number} [options.concurrentNum=10] - 并發(fā)數(shù)
     * @param {Function} [options.chunkCallback] - 分塊回調(diào) 
     */
    exec(options) {
        this.canceled = false
        this.#batchRequest(options)
    }

    /**
     * 取消所有請求任務(wù)
     */
    cancelAll() {
        this.canceled = true
        for(const task of this.resTasks) {
            task.abort()
        }
        this.resTasks = []
    }
}