import { generateNewIdAsync } from 'oak-domain/lib/utils/uuid';
import { DATA_SUBSCRIBER_KEYS } from '../config/constants';
import assert from 'assert';
import { getShipEntity } from '../utils/shipClazz';
import { getShipState, uploadShippingInfo } from '../utils/ship';
const triggers = [
    {
        name: '当虚拟或自提类型的ship创建后自动发货',
        entity: 'ship',
        action: 'create',
        when: 'commit',
        strict: 'makeSure',
        asRoot: true,
        check: (operation) => ['virtual', 'pickup'].includes(operation.data.type),
        fn: async ({ ids }, context, option) => {
            for (const id of ids) {
                await context.operate('ship', {
                    id: await generateNewIdAsync(),
                    action: 'ship',
                    data: {},
                    filter: {
                        id,
                    }
                }, option);
            }
            return;
        },
    },
    {
        entity: 'ship',
        name: '当虚拟的ship变为shipping状态时，调用小程序发货信息录入接口',
        action: 'ship',
        when: 'before',
        asRoot: true,
        priority: 99,
        fn: async ({ operation }, context) => {
            const { data, filter } = operation;
            const [ship] = await context.select('ship', {
                data: {
                    id: 1,
                    type: 1,
                    deposit$ship: {
                        $entity: 'deposit',
                        data: {
                            id: 1,
                        },
                        indexFrom: 0,
                        count: 1,
                    }
                },
                filter,
            }, {});
            const { type, deposit$ship: deposits } = ship || {};
            if (type === 'virtual') {
                const deposit = deposits?.[0];
                //当已发货的订单再次调用小程序发货信息录入接口视为重新发货(仅可重新发货一次)
                //发货前先查询，检查是否为未同步微信端发货状态
                const shipState = await getShipState(context, deposit);
                if (shipState === 'unshipped') {
                    const result = await uploadShippingInfo({ depositId: deposit?.id, }, context);
                    if (result) {
                        return 1;
                    }
                }
            }
            return 0;
        }
    },
    {
        entity: 'ship',
        name: '当ship状态发生变化时，尝试向订阅者推送',
        action: ['ship', 'receive', 'giveUp', 'reject'],
        when: 'after',
        fn: async ({ operation }, context, option) => {
            const { filter, id } = operation;
            const { id: shipId } = filter;
            if (shipId) {
                context.saveOperationToEvent(id, `${DATA_SUBSCRIBER_KEYS.shipStateChanged}-${shipId}`);
            }
            return 1;
        }
    },
    {
        name: '当物流创建时，将对应的receivingMethod为express的order变为packaged状态',
        entity: 'ship',
        action: 'create',
        when: 'after',
        fn: async ({ operation }, context, option) => {
            const { data } = operation;
            const orders = await context.select('order', {
                data: {
                    id: 1,
                    gState: 1,
                },
                filter: {
                    receivingMethod: 'express',
                    shipOrder$order: {
                        shipId: data.id,
                    }
                }
            }, { dontCollect: true });
            orders.forEach(ele => assert(ele.gState === 'unshipped'));
            await context.operate('order', {
                id: await generateNewIdAsync(),
                action: 'package',
                data: {},
                filter: {
                    id: {
                        $in: orders.map(ele => ele.id),
                    },
                },
            }, option);
            return orders.length;
        }
    },
    {
        name: '当物流创建时，赋上对应的物流系统对象',
        entity: 'ship',
        action: 'create',
        when: 'before',
        fn: async ({ operation }, context) => {
            const result = await getShipEntity(context);
            if (result) {
                const { data } = operation;
                if (data instanceof Array) {
                    data.forEach(ele => {
                        ele.entity = result[0];
                        ele.entityId = result[1];
                    });
                }
                else {
                    data.entity = result[0];
                    data.entityId = result[1];
                }
                return 1;
            }
            return 0;
        }
    },
    {
        name: '当物流发货时，将对应的order状态变为已发货/提货中',
        entity: 'ship',
        action: 'ship',
        when: 'after',
        fn: async ({ operation }, context, option) => {
            const { filter } = operation;
            assert(typeof filter.id === 'string');
            const orders = await context.select('order', {
                data: {
                    id: 1,
                    gState: 1,
                },
                filter: {
                    shipOrder$order: {
                        shipId: filter.id,
                    }
                }
            }, { dontCollect: true });
            const packaged = orders.filter(ele => ele.gState === 'packaged');
            if (packaged.length > 0) {
                await context.operate('order', {
                    id: await generateNewIdAsync(),
                    action: 'ship',
                    data: {},
                    filter: {
                        id: {
                            $in: packaged.map(ele => ele.id),
                        },
                    },
                }, option);
            }
            const staged = orders.filter(ele => ele.gState === 'staging');
            if (staged.length > 0) {
                await context.operate('order', {
                    id: await generateNewIdAsync(),
                    action: 'startTaking',
                    data: {},
                    filter: {
                        id: {
                            $in: staged.map(ele => ele.id),
                        },
                    },
                }, option);
            }
            assert(staged.length + packaged.length === orders.length);
            return orders.length;
        }
    }
];
export default triggers;