'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

class rptMemBase {
    constructor(ctx, bindData) {
        this.ctx = ctx;
        // 绑定表配置 -- 绑定表指几个数据表，共用一个加载逻辑，存在任一张时，其他表均同步加载
        this.bindData = bindData;
    }

    /**
     * 数据表分类（普通表，绑定表）
     * @param sourceFilters
     * @returns {*[]}
     */
    getFilter(sourceFilters) {
        const common = [], spec = [];
        for (const sf of sourceFilters) {
            let bSpec = false;
            for (const key in this.bindData) {
                const b = this.bindData[key];
                if (b.indexOf(sf) >= 0) {
                    bSpec = true;
                    if (spec.indexOf(key) === -1) {
                        spec.push(key);
                        break;
                    }
                }
            }
            if (!bSpec) common.push(sf);
        }
        return [common, spec];
    }

    getFieldKeys(source, filter) {
        const result = [];
        for (const f of filter) {
            if (source[f]) result.push(...source[f]);
        }
        return result;
    }

    /**
     * 获取普通表数据(请在子类重构)
     * @param params 报表基础传参
     * @param tableName 表名
     * @param fields 数据列名
     * @returns {Promise<void>}
     */
    getCommonData(params, tableName, fields) {
        throw '基础报表数据不可使用';
    }

    /**
     * 获取绑定表数据(请在子类重构)
     * @param params 报表基础传参
     * @param key
     * @param fields 数据列名
     * @returns {Promise<void>}
     */
    async getBindData(params, key, fields) {
        throw '基础报表数据不可使用';
    }

    /**
     * 读取报表数据前的预加载部分，子类按需重构
     * @returns {Promise<void>}
     */
    async doBeforeLoadReport(params) {
        return;
    }

    /**
     * 获取报表数据
     * @param params 报表基础传参
     * @param sourceFilters 数据表
     * @param memFieldKeys 数据表-数据列
     * @returns {Promise<void>}
     */
    async getReportData(params, sourceFilters, memFieldKeys) {
        // 预加载部分（tenderCheck,stageCheck,paymentSafeCheck...）
        await this.doBeforeLoadReport(params);

        const rst = {};
        // 数据表分类为普通表，绑定表
        const [filters, bindFilters] = this.getFilter(sourceFilters);
        // 加载普通表数据
        const runnableRst = [];
        const runnableKey = []; // 这个配合runnableRst用，未来考虑并行查询优化
        for (const filter of filters) {
            if (runnableKey.indexOf(filter) >= 0) return;
            runnableKey.push(filter);
            runnableRst.push(this.getCommonData(params, filter, memFieldKeys[filter]));
        }
        const queryRst = await Promise.all(runnableRst);
        for (let idx = 0; idx < runnableKey.length; idx++) {
            rst[runnableKey[idx]] = queryRst[idx];
        }
        // 加载绑定表数据局
        for (const bindFilter of bindFilters) {
            const resultData = await this.getBindData(params, this.getFieldKeys(memFieldKeys, this.bindData[bindFilter]));
            for (const d in resultData) {
                rst[d] = resultData[d];
            }
        }
        return rst;
    }
}

module.exports = rptMemBase;