package com.dderp.business.service.flycat;

import com.dderp.common.api.flycat.OrderSearchService;
import com.dderp.common.base.BaseService;
import com.dderp.common.datas.ERPModule;
import com.dderp.common.datas.ReadOrderOption;
import com.dderp.common.entity.base.ProcessSearchOptionsItem;
import com.dderp.common.entity.order.BusinessOrder;
import com.dderp.common.entity.site.ERPTokenUser;
import com.dderp.common.tool.ERPUtils;
import com.sweetfish.service.Local;
import com.sweetfish.service.RetResult;
import com.sweetfish.source.PageFlipper;
import com.sweetfish.util.AnyValue;
import com.sweetfish.util.AutoLoad;
import com.sweetfish.util.ObjectPool;
import com.sweetfish.util.ResourceType;
import org.rex.RMap;

import java.util.List;

/**
 * 订单搜索服务
 * 前端页面上调用搜索可以做到完全脚本化，因为它的查询总是返回json即可，查询功能也基本固定
 * 但服务之间调用搜索就很麻烦做到这一点了，不能只调用callScript，原因如下
 * 1、InvokeCallParams功能太单一，服务间调用条件太多，一个对象搞不定
 * 2、InvokeCallResult在脚本中序列化后，还需要调用方反序列化，多了一步无效的json操作
 * 3、服务之间调用返回值确实不一样，有的需要订单主表，有的需要订单带部件，有的只要部件，而且带不带子表无法固定，
 * 所以为了兼顾上面说的几点，有一些硬编码必不可少
 * 可以把订单所有的对象抽象为两类操作，一种为获取单个对象，一种为获取数组，这样只要结构不动的情况下，可以做到脚本化，而如果结构动，反正是要编译的
 * 另外要少写一些固定的代码，条件全部用RMap传递，groovy里面初始化一个map对象还是很方便的
 */
@AutoLoad(false)
@Local
@ResourceType(OrderSearchService.class)
public class OrderSearchServiceImpl extends BaseService implements OrderSearchService {

    private final ObjectPool<RMap<String, Long>> idsMap = new ObjectPool<>(100,
            () -> new RMap<>(),
            null,
            (t) -> {
                t.clear();
                return true;
            });

    @Override
    public void init(AnyValue config) {
        super.init(config);
    }

    @Override
    public void destroy(AnyValue config) {
        super.destroy(config);
    }

    /**
     * 查询单个订单信息
     * <br>在groovy里面使用可以按下面的方法调用
     * <br>RetResult<PrintOrder> orderResult = orderSearchService.searchBusinessOrder(new RMap<>(ERPUtils.PARAM_SEARCH_ID: 100L), currentUser, dataSourceId, supplierCode)
     * <br>或者在java里面封装一个
     * <br> getBusinessOrder(long id)的方法，提供给其它服务调用，写法差不多，简化不了一行代码
     *
     * @param searchData   查询条件
     * @param currentUser  操作人
     * @param dataSourceId 分库
     * @param supplierCode 分表
     * @param options      子表读取规则
     * @return 订单信息
     */
    @SuppressWarnings("rawtypes")
    public RetResult<BusinessOrder> searchBusinessOrder(RMap searchData,
                                                        ERPTokenUser currentUser,
                                                        String dataSourceId,
                                                        long supplierCode,
                                                        ReadOrderOption[] options) {
        return handleScript("ERP_BusinessOrder_Search", ERPModule.ERP_ORDER_SEARCH,
                dataSourceId, supplierCode,
                () -> ProcessSearchOptionsItem.<ReadOrderOption>newBuilder()
                        .searchData(searchData)
                        .options(options)
                        .currentUser(currentUser)
                        .dataSourceId(dataSourceId)
                        .supplierCode(supplierCode)
                        .build()
        );
    }

    /**
     * 获取单个订单信息
     * 对searchBusinessOrder的简单封装
     *
     * @param idOrder      订单id
     * @param currentUser  操作人
     * @param dataSourceId 分库
     * @param supplierCode 分表
     * @param options      子表读取规则
     * @return 订单信息
     */
    public RetResult<BusinessOrder> getBusinessOrder(long idOrder,
                                                     ERPTokenUser currentUser,
                                                     String dataSourceId,
                                                     long supplierCode,
                                                     ReadOrderOption[] options) {
        RMap<String, Long> longRMap = idsMap.get();
        try {
            longRMap.put(ERPUtils.PARAM_SEARCH_ID, idOrder);
            //searchBusinessOrder是同步调用的，所以可以这样try finally，如果有异步情况，则在完成里面调用，参考doId之类的实现
            return searchBusinessOrder(longRMap, currentUser, dataSourceId, supplierCode, options);
        } finally {
            idsMap.accept(longRMap);
        }
    }

    /**
     * 多订单查询，无需分页参数，
     * <br>在groovy里面使用可以按下面的方法调用，比如通过多id获取订单
     * <br>RetResult<List<PrintOrder></PrintOrder>> orderResult = orderSearchService.searchPrintOrderList(new RMap<>(ERPUtils.PARAM_SEARCH_IDS: "1,2,3"), currentUser, dataSourceId, supplierCode)
     * <br>或者在java里面封装一个
     * <br> getPrintOrder(long id)的方法，提供给其它服务调用，写法差不多，简化不了一行代码
     *
     * @param searchData   查询条件
     * @param currentUser  操作人
     * @param dataSourceId 分库
     * @param supplierCode 分表
     * @param options      子表读取规则
     * @return 订单列表
     */
    @SuppressWarnings("rawtypes")
    public RetResult<List<BusinessOrder>> searchBusinessOrderList(RMap searchData,
                                                                  ERPTokenUser currentUser,
                                                                  String dataSourceId,
                                                                  long supplierCode,
                                                                  ReadOrderOption[] options) {
        return handleScriptList("ERP_BusinessOrder_Search", ERPModule.ERP_ORDER_SEARCH,
                dataSourceId, supplierCode,
                () -> ProcessSearchOptionsItem.<ReadOrderOption>newBuilder()
                        .searchData(searchData)
                        .options(options)
                        .currentUser(currentUser)
                        .dataSourceId(dataSourceId)
                        .supplierCode(supplierCode)
                        .build()
        );
    }

    /**
     * 多订单分页查询
     *
     * @param searchData   查询条件
     * @param currentUser  操作人
     * @param orderBy      排序
     * @param pageFlipper  分页
     * @param dataSourceId 分库
     * @param supplierCode 分表
     * @param options      子表读取规则
     * @return 订单列表
     */
    @SuppressWarnings("rawtypes")
    public RetResult<List<BusinessOrder>> searchBusinessOrderList(RMap searchData,
                                                                  ERPTokenUser currentUser,
                                                                  String orderBy,
                                                                  PageFlipper pageFlipper,
                                                                  String dataSourceId,
                                                                  long supplierCode,
                                                                  ReadOrderOption[] options) {
        return handleScriptList("ERP_BusinessOrder_Search", ERPModule.ERP_ORDER_SEARCH,
                dataSourceId, supplierCode,
                () -> ProcessSearchOptionsItem.<ReadOrderOption>newBuilder()
                        .searchData(searchData)
                        .pageFlipper(pageFlipper)
                        .orderBy(orderBy)
                        .options(options)
                        .currentUser(currentUser)
                        .dataSourceId(dataSourceId)
                        .supplierCode(supplierCode)
                        .build()
        );
    }
}