"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TriggerExecutor = void 0;
const tslib_1 = require("tslib");
const assert_1 = tslib_1.__importDefault(require("assert"));
const lodash_1 = require("../utils/lodash");
const filter_1 = require("../store/filter");
const Entity_1 = require("../types/Entity");
const Trigger_1 = require("../types/Trigger");
const SyncRowStore_1 = require("./SyncRowStore");
const checker_1 = require("./checker");
const uuid_1 = require("../utils/uuid");
const action_1 = require("../actions/action");
const types_1 = require("../types");
/**
 * update可能会传入多种不同的action，此时都需要检查update trigger
 */
/* const UnifiedActionMatrix: Record<string, string> = {
    'create': 'create',
    'remove': 'remove',
    'select': 'select',
    'download': 'select',
    'count': 'select',
    'stat': 'select',
}; */
class TriggerExecutor {
    counter;
    triggerMap;
    triggerNameMap;
    volatileEntities;
    logger;
    contextBuilder;
    onVolatileTrigger;
    constructor(contextBuilder, logger = console, onVolatileTrigger) {
        this.contextBuilder = contextBuilder;
        this.logger = logger;
        this.triggerMap = {};
        this.triggerNameMap = {};
        this.volatileEntities = [];
        this.counter = 0;
        this.onVolatileTrigger = onVolatileTrigger || (async (entity, trigger, ids, cxtStr, option) => {
            const context = this.contextBuilder();
            if (!context.getCurrentTxnId()) {
                await context.begin();
            }
            await context.initialize(JSON.parse(cxtStr), true);
            try {
                await this.execVolatileTrigger(entity, trigger.name, ids, context, option);
                await context.commit();
            }
            catch (err) {
                if (!(err instanceof types_1.OakPartialSuccess)) {
                    await context.rollback();
                    this.logger.error('error on volatile trigger', entity, trigger.name, ids.join(','), err);
                }
                else {
                    await context.commit();
                    this.logger.error('error on volatile trigger', entity, trigger.name, ids.join(','), err);
                }
                // throw err;
            }
        });
    }
    setOnVolatileTrigger(onVolatileTrigger) {
        this.onVolatileTrigger = onVolatileTrigger;
    }
    registerChecker(checker, schema) {
        const { entity, action, type, mt } = checker;
        const triggerName = `${String(entity)}${action}权限检查-${this.counter++}`;
        const { fn, when } = (0, checker_1.translateCheckerInAsyncContext)(checker, schema);
        const trigger = {
            checkerType: type,
            name: triggerName,
            priority: checker.priority || Trigger_1.CHECKER_PRIORITY_MAP[type],
            entity,
            action: action,
            fn,
            when,
            mt,
            filter: checker.conditionalFilter,
        };
        this.registerTrigger(trigger);
    }
    /*  getCheckers<T extends keyof ED>(entity: T, action: ED[T]['Action'], checkerTypes?: CheckerType[]) {
         const triggers = this.triggerMap[entity] && this.triggerMap[entity]![action]?.filter(
             trigger => (typeof trigger.action === 'string' && trigger.action === action || trigger.action instanceof Array && trigger.action.includes(action as any)
                 && (!checkerTypes || trigger.checkerType && checkerTypes.includes(trigger.checkerType)))
         );
         return triggers;
     } */
    registerTrigger(trigger) {
        // trigger的两种访问方式: by name, by entity/action
        if (this.triggerNameMap.hasOwnProperty(trigger.name)) {
            throw new Error(`不可有同名的触发器「${trigger.name}」`);
        }
        if (typeof trigger.priority !== 'number') {
            trigger.priority = Trigger_1.TRIGGER_DEFAULT_PRIORITY; // 默认值
        }
        else {
            (0, assert_1.default)(trigger.priority <= Trigger_1.CHECKER_MAX_PRIORITY && trigger.priority >= Trigger_1.TRIGGER_MIN_PRIORITY, `trigger「${trigger.name}」的优先级定义越界，应该在${Trigger_1.TRIGGER_MIN_PRIORITY}到${Trigger_1.CHECKER_MAX_PRIORITY}之间`);
        }
        if (trigger.filter) {
            (0, assert_1.default)(typeof trigger.action === 'string' && trigger.action !== 'create'
                || trigger.action instanceof Array && !trigger.action.includes('create'), `trigger【${trigger.name}】是create类型但却带有filter`);
            (0, assert_1.default)(trigger.when === 'before' || trigger.when === 'commit', `定义了filter的trigger【${trigger.name}】的when只能是before或者commit`);
        }
        Object.assign(this.triggerNameMap, {
            [trigger.name]: trigger,
        });
        const addTrigger = (action) => {
            const triggers = this.triggerMap[trigger.entity] && this.triggerMap[trigger.entity][action];
            if (triggers) {
                let idx;
                // 这里可以保持有序插入，后面取trigger的时候就不用排序了
                for (idx = 0; idx < triggers.length; idx++) {
                    if (triggers[idx].priority > trigger.priority) {
                        break;
                    }
                }
                triggers.splice(idx, 0, trigger);
            }
            else if (this.triggerMap[trigger.entity]) {
                Object.assign(this.triggerMap[trigger.entity], {
                    [action]: [trigger],
                });
            }
            else {
                Object.assign(this.triggerMap, {
                    [trigger.entity]: {
                        [action]: [trigger],
                    }
                });
            }
        };
        if (typeof trigger.action === 'string') {
            addTrigger(trigger.action);
        }
        else {
            trigger.action.forEach(ele => addTrigger(ele));
        }
        if (trigger.when === 'commit' && trigger.strict === 'makeSure') {
            if (this.volatileEntities.indexOf(trigger.entity) === -1) {
                this.volatileEntities.push(trigger.entity);
            }
        }
    }
    unregisterTrigger(trigger) {
        (0, assert_1.default)(trigger.when !== 'commit' || trigger.strict !== 'makeSure', 'could not remove strict volatile triggers');
        const removeTrigger = (action) => {
            const triggers = this.triggerMap[trigger.entity] && this.triggerMap[trigger.entity][action];
            if (triggers) {
                (0, lodash_1.pull)(triggers, trigger);
                (0, lodash_1.unset)(this.triggerNameMap, trigger.name);
            }
        };
        if (typeof trigger.action === 'string') {
            removeTrigger(trigger.action);
        }
        else {
            trigger.action.forEach(ele => removeTrigger(ele));
        }
    }
    async preCommitTrigger(entity, operation, trigger, context, option) {
        (0, assert_1.default)(trigger.action !== 'select');
        (0, assert_1.default)(trigger.when === 'commit');
        if (trigger.strict === 'makeSure') {
            const uuid = await (0, uuid_1.generateNewIdAsync)();
            const cxtStr = await context.toString();
            const { data } = operation;
            switch (operation.action) {
                case 'create': {
                    if (data instanceof Array) {
                        data.forEach((d) => {
                            if (d.hasOwnProperty(Entity_1.TriggerDataAttribute) || d.hasOwnProperty(Entity_1.TriggerUuidAttribute)) {
                                throw new Error('同一行数据上不能同时存在两个跨事务约束');
                            }
                        });
                    }
                    else {
                        if (data.hasOwnProperty(Entity_1.TriggerDataAttribute) || data.hasOwnProperty(Entity_1.TriggerUuidAttribute)) {
                            throw new Error('同一行数据上不能存在两个跨事务约束');
                        }
                    }
                    break;
                }
                default: {
                    const { filter } = operation;
                    // 此时要保证更新或者删除的行上没有跨事务约束
                    const filter2 = (0, filter_1.combineFilters)(entity, context.getSchema(), [{
                            [Entity_1.TriggerUuidAttribute]: {
                                $exists: true,
                            },
                        }, filter]);
                    const count = await context.count(entity, {
                        filter: filter2
                    }, {});
                    if (count > 0) {
                        throw new Error(`对象${String(entity)}的行「${JSON.stringify(operation)}」上已经存在未完成的跨事务约束`);
                    }
                    break;
                }
            }
            if (data instanceof Array) {
                data.forEach((d) => {
                    Object.assign(d, {
                        [Entity_1.TriggerDataAttribute]: {
                            name: trigger.name,
                            cxtStr,
                            option,
                        },
                        [Entity_1.TriggerUuidAttribute]: uuid,
                    });
                });
            }
            else {
                Object.assign(data, {
                    [Entity_1.TriggerDataAttribute]: {
                        name: trigger.name,
                        cxtStr,
                        option,
                    },
                    [Entity_1.TriggerUuidAttribute]: uuid,
                });
            }
        }
    }
    postCommitTrigger(entity, operation, trigger, context, option) {
        context.on('commit', async (opRecords, cxtStr) => {
            let ids = [];
            let cxtStr2 = cxtStr;
            const { data } = operation;
            if (operation.action === 'create') {
                if (data instanceof Array) {
                    ids = data.map(ele => ele.id);
                    if (data[0].$$triggerData$$?.cxtStr) {
                        cxtStr2 = data[0].$$triggerData$$?.cxtStr;
                    }
                }
                else {
                    ids = [data.id];
                    if (data.$$triggerData$$?.cxtStr) {
                        cxtStr2 = data.$$triggerData$$?.cxtStr;
                    }
                }
            }
            else {
                /**
                 * 若trigger是makeSure，则应使用当时缓存的cxt（有可能是checkpoint反复调用）
                 * 若trigger是takeEasy，只会在事务提交时做一次，使用当前context应也无大问题
                 * 暂时先这样设计，若当前提交事务中改变了cxt内容，也许会有问题。by Xc 20240319
                 */
                if (data.$$triggerData$$?.cxtStr) {
                    cxtStr2 = data.$$triggerData$$?.cxtStr;
                }
                const record = opRecords.find(ele => ele.id === operation.id);
                if (record) {
                    // 目前框架在operation时，一定会将ids记录在operation当中（见CascadeStore中的doUpdateSingleRowAsync函数
                    // 但也有一种可能，此operation没有更新任何一行。by Xc 20241022
                    (0, assert_1.default)(record.a !== 'c');
                    const { f } = record;
                    ids = f.id.$in;
                }
            }
            // 此时项目的上下文，和执行此trigger时的上下文可能不一致（rootMode），采用当时的上下文cxtStr来执行
            this.onVolatileTrigger(entity, trigger, ids, cxtStr2, option);
        });
    }
    preOperation(entity, operation, context, option) {
        const { action } = operation;
        const triggers = this.triggerMap[entity] && this.triggerMap[entity][action]?.filter(trigger => (typeof trigger.action === 'string' && trigger.action === operation.action
            || trigger.action instanceof Array && trigger.action.includes(operation.action))
            // 加上modi的过滤条件
            && this.judgeModiTurn(option, trigger));
        if (triggers) {
            const preTriggers = triggers.filter(ele => ele.when === 'before' && (!ele.check || ele.check(operation)));
            const commitTriggers = triggers.filter(ele => ele.when === 'commit' &&
                (!ele.check || ele.check(operation)));
            if (context instanceof SyncRowStore_1.SyncContext) {
                for (const trigger of preTriggers) {
                    if (trigger.filter) {
                        // trigger只对满足条件的前项进行判断，如果确定不满足可以pass
                        (0, assert_1.default)(operation.action !== 'create');
                        const { filter } = trigger;
                        const filterr = typeof filter === 'function' ? filter(operation, context, option) : filter;
                        (0, assert_1.default)(!(filterr instanceof Promise));
                        const filterRepelled = (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter);
                        if (filterRepelled) {
                            continue;
                        }
                    }
                    const number = trigger.fn({ operation: operation }, context, option);
                    if (number > 0 && process.env.NODE_ENV === 'development') {
                        this.logger.info(`前触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                    }
                }
                (0, assert_1.default)(commitTriggers.length === 0, `前台不应有commitTrigger`);
            }
            else {
                // 异步context
                const execPreTrigger = async (idx) => {
                    if (idx >= preTriggers.length) {
                        return;
                    }
                    const trigger = preTriggers[idx];
                    if (trigger.filter) {
                        (0, assert_1.default)(operation.action !== 'create');
                        const { filter } = trigger;
                        const filterr = typeof filter === 'function' ? await filter(operation, context, option) : filter;
                        const filterRepelled = await (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter);
                        if (filterRepelled) {
                            return execPreTrigger(idx + 1);
                        }
                    }
                    const closeRoot = trigger.asRoot && context.openRootMode();
                    try {
                        const number = await trigger.fn({ operation: operation }, context, option);
                        if (number > 0 && process.env.NODE_ENV === 'development') {
                            this.logger.info(`前触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                        }
                        closeRoot && closeRoot();
                    }
                    catch (err) {
                        closeRoot && closeRoot();
                        throw err;
                    }
                    return execPreTrigger(idx + 1);
                };
                const execCommitTrigger = async (idx) => {
                    if (idx >= commitTriggers.length) {
                        return;
                    }
                    (0, assert_1.default)(!action_1.readOnlyActions.includes(operation.action), '当前应该不支持select的跨事务trigger');
                    const trigger = commitTriggers[idx];
                    if (trigger.filter) {
                        (0, assert_1.default)(operation.action !== 'create');
                        const { filter } = trigger;
                        const filterr = typeof filter === 'function' ? await filter(operation, context, option) : filter;
                        const filterRepelled = await (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter);
                        if (filterRepelled) {
                            return execCommitTrigger(idx + 1);
                        }
                    }
                    await this.preCommitTrigger(entity, operation, trigger, context, option);
                    return execCommitTrigger(idx + 1);
                };
                return execPreTrigger(0)
                    .then(() => execCommitTrigger(0));
            }
        }
    }
    async execVolatileTrigger(entity, name, ids, context, option) {
        const trigger = this.triggerNameMap[name];
        (0, assert_1.default)(trigger && trigger.when === 'commit');
        // assert(ids.length > 0);
        const { fn } = trigger;
        const closeRoot = trigger.asRoot && context.openRootMode();
        try {
            const callback = await fn({ ids }, context, option);
            if (trigger.strict === 'makeSure' && ids.length) {
                // 这里开root模式，否则还可能有权限问题
                const closeRoot2 = context.openRootMode();
                try {
                    await context.operate(entity, {
                        id: await (0, uuid_1.generateNewIdAsync)(),
                        action: 'update',
                        data: {
                            [Entity_1.TriggerDataAttribute]: null,
                            [Entity_1.TriggerUuidAttribute]: null,
                        },
                        filter: {
                            id: {
                                $in: ids,
                            },
                            [Entity_1.TriggerDataAttribute]: {
                                $exists: true,
                            },
                            [Entity_1.TriggerUuidAttribute]: {
                                $exists: true,
                            }
                        }
                    }, { includedDeleted: true, blockTrigger: true });
                    closeRoot2 && closeRoot2();
                }
                catch (err2) {
                    closeRoot2 && closeRoot2();
                    throw err2;
                }
            }
            if (typeof callback === 'function') {
                await callback(context, option);
            }
            closeRoot && closeRoot();
        }
        catch (err) {
            closeRoot && closeRoot();
            throw err;
        }
    }
    /**
     * 判断一个trigger和当前modi上下文是否符合
     * trigger的默认行为是：如果是commit时机的trigger，不显式声明则只能在modi apply时执行（create时不执行）；非commit时机的trigger，不显式声明则只在modi create时执行
     * @param option
     * @param trigger
     * @returns
     */
    judgeModiTurn(option, trigger) {
        const { mt, when } = trigger;
        if (option.modiParentEntity) {
            // 在创建modi过程中，标识为apply或者未标识但为commit时执行的trigger默认不能执行
            return mt && ['both', 'create'].includes(mt) || !mt && when !== 'commit';
        }
        else if (option.applyingModi) {
            // 在应用modi过程中，标识为create或者未标识但不为commit时执行的trigger默认不能执行
            return mt && ['both', 'apply'].includes(mt) || !mt && when === 'commit';
        }
        return true;
    }
    postOperation(entity, operation, context, option, result) {
        const { action } = operation;
        const triggers = this.triggerMap[entity] && this.triggerMap[entity][action]?.filter(trigger => (typeof trigger.action === 'string' && trigger.action === operation.action
            || trigger.action instanceof Array && trigger.action.includes(operation.action))
            // 加上modi的过滤条件
            && this.judgeModiTurn(option, trigger));
        if (triggers) {
            const postTriggers = triggers.filter(ele => ele.when === 'after' && (!ele.check || ele.check(operation)));
            const commitTriggers = triggers.filter(ele => ele.when === 'commit' &&
                (!ele.check || ele.check(operation)));
            if (context instanceof SyncRowStore_1.SyncContext) {
                for (const trigger of postTriggers) {
                    const number = trigger.fn({
                        operation: operation,
                        result: result,
                    }, context, option);
                    if (number > 0 && process.env.NODE_ENV === 'development') {
                        this.logger.info(`后触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                    }
                }
            }
            else {
                // 异步context
                const execPostTrigger = async (idx) => {
                    if (idx >= postTriggers.length) {
                        return;
                    }
                    const trigger = postTriggers[idx];
                    const closeRoot = trigger.asRoot && context.openRootMode();
                    try {
                        const number = await trigger.fn({
                            operation: operation,
                            result: result,
                        }, context, option);
                        if (number > 0 && process.env.NODE_ENV === 'development') {
                            this.logger.info(`后触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                        }
                        closeRoot && closeRoot();
                    }
                    catch (err) {
                        closeRoot && closeRoot();
                        throw err;
                    }
                    return execPostTrigger(idx + 1);
                };
                const execCommitTrigger = async (idx) => {
                    if (idx >= commitTriggers.length) {
                        return;
                    }
                    (0, assert_1.default)(!action_1.readOnlyActions.includes(operation.action), '当前应该不支持select的跨事务trigger');
                    const trigger = commitTriggers[idx];
                    if (trigger.filter) {
                        (0, assert_1.default)(operation.action !== 'create');
                        const { filter } = trigger;
                        const filterr = typeof filter === 'function' ? await filter(operation, context, option) : filter;
                        const filterRepelled = await (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter);
                        if (filterRepelled) {
                            return execCommitTrigger(idx + 1);
                        }
                    }
                    this.postCommitTrigger(entity, operation, trigger, context, option);
                    return execCommitTrigger(idx + 1);
                };
                return execPostTrigger(0)
                    .then(() => execCommitTrigger(0));
            }
        }
    }
    async checkpoint(timestamp) {
        let result = 0;
        for (const name in this.triggerNameMap) {
            result += await this.independentCheckPoint(name, timestamp);
        }
        return result;
    }
    /**
     * 由外部来控制进行按volatileTrigger逐个进行checkpoint
     * @param name
     * @param timestamp
     * @param instanceCount
     * @param instanceId
     */
    async independentCheckPoint(name, timestamp, instanceCount, instanceId) {
        const trigger = this.triggerNameMap[name];
        (0, assert_1.default)(trigger && trigger.when === 'commit');
        const { fn, entity, grouped } = trigger;
        const filter = {
            [Entity_1.TriggerDataAttribute]: {
                name,
            },
            [Entity_1.TriggerUuidAttribute]: {
                $exists: true,
            },
            [Entity_1.UpdateAtAttribute]: {
                $lt: timestamp,
            },
        };
        if (instanceCount) {
            filter.$$seq$$ = {
                $mod: [instanceCount, instanceId]
            };
        }
        const context = this.contextBuilder();
        await context.begin();
        try {
            const rows = await context.select(entity, {
                data: {
                    id: 1,
                },
                filter,
            }, {
                includedDeleted: true,
                dontCollect: true,
            });
            if (rows.length > 0) {
                // 要用id来再锁一次，不然会锁住filter的范围，影响并发性
                // by Xc 20240314，在haina-busi和haina-cn数据sync过程中发现这个问题
                const rows2 = await context.select(entity, {
                    data: {
                        id: 1,
                        [Entity_1.TriggerDataAttribute]: 1,
                        [Entity_1.TriggerUuidAttribute]: 1,
                    },
                    filter: {
                        id: {
                            $in: rows.map(ele => ele.id),
                        },
                    },
                }, {
                    includedDeleted: true,
                    dontCollect: true,
                    forUpdate: 'skip locked', // 如果加不上锁就下次再处理，或者有可能应用自己在处理
                });
                if (grouped) {
                    // grouped不需要上下文了吧，内部一定会用root
                    await this.execVolatileTrigger(entity, name, rows.map(ele => ele.id), context, {});
                }
                else {
                    const groupedRowDict = (0, lodash_1.groupBy)(rows2, Entity_1.TriggerUuidAttribute);
                    for (const uuid in groupedRowDict) {
                        const rs = groupedRowDict[uuid];
                        const { [Entity_1.TriggerDataAttribute]: triggerData } = rs[0];
                        const { cxtStr, option } = triggerData;
                        await context.initialize(JSON.parse(cxtStr), true);
                        await this.execVolatileTrigger(entity, name, rs.map(ele => ele.id), context, option);
                    }
                }
            }
            await context.commit();
            return rows.length;
        }
        catch (err) {
            if (!(err instanceof types_1.OakPartialSuccess)) {
                await context.rollback();
                this.logger.error('error on volatile trigger', entity, trigger.name, err);
            }
            else {
                await context.commit();
                this.logger.error('error on volatile trigger', entity, trigger.name, err);
            }
            return 0;
        }
    }
}
exports.TriggerExecutor = TriggerExecutor;