package com.infoloop.tianting.service.client;

import com.infoloop.tianting.SingleResponse;
import com.infoloop.tianting.SingleSkuResponse;
import com.infoloop.tianting.SingleSpecialResponse;
import com.infoloop.tianting.clientcustomerorderservice.AddSkusSellQuantitiesRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsRequest;
import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsResponse;
import com.infoloop.tianting.clientcustomerorderservice.BatchSaveSkuSellQuantitiesRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrdersRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderCreation;
import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderDetailCreation;
import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderDetailModification;
import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderModification;
import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderServiceRpcGrpc;
import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
import com.infoloop.tianting.clientcustomerorderservice.CreateClientCustomerOrderRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.CustomerNotice;
import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderByIdRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderDetailsByIdsRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderDetailsByOrderIdsRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrdersByCustomerIdRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecordsByOrderIdsRequest;
import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecordsByOrderIdsResponse;
import com.infoloop.tianting.clientcustomerorderservice.MealDetail;
import com.infoloop.tianting.clientcustomerorderservice.OnlinePayEnum;
import com.infoloop.tianting.clientcustomerorderservice.OrderOperationRecordCreation;
import com.infoloop.tianting.clientcustomerorderservice.OrderOperationType;
import com.infoloop.tianting.clientcustomerorderservice.OrderSourceEnum;
import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.OrderTypeEnum;
import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.ReleaseSkusSellQuantitiesRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.ServeStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SingleSkuSellQuantityRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantity;
import com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantityModification;
import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcRequest;
import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcResponse;
import com.infoloop.tianting.clientresourcetagservice.SingleResourceLabelEntityRefsResponse;
import com.infoloop.tianting.context.LoginContextHolder;
import com.infoloop.tianting.exception.ClientEndExceptions;
import com.infoloop.tianting.exception.ErrorCodeEnum;
import com.infoloop.tianting.logic.delay.DelayedQueue;
import com.infoloop.tianting.logic.delay.OrderAutoCancelDelayTask;
import com.infoloop.tianting.logic.delay.param.AutoCancelParam;
import com.infoloop.tianting.menuservice.CloseTimeTypeEnum;
import com.infoloop.tianting.menuservice.ModeOfPaymentEnum;
import com.infoloop.tianting.model.bo.AddSkusSellQuantityBO;
import com.infoloop.tianting.model.bo.SkuSellQuantityBO;
import com.infoloop.tianting.model.dto.OperationDTO.BatchOperationDto;
import com.infoloop.tianting.model.dto.OperationDTO.SingleOperationDto;
import com.infoloop.tianting.model.dto.OrderDbDTO;
import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDetailDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderResponse;
import com.infoloop.tianting.model.dto.OrderDbDTO.MealDetailDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.OrderDetailBatchUpdateDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.OrderDetailDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.OrderDetailOperationDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByConditionDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByPaginationDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.QueryRefundOrderByPaginationDto;
import com.infoloop.tianting.model.dto.OrderDbDTO.UpdateOrderDto;
import com.infoloop.tianting.server.UserAuthData;
import com.infoloop.tianting.server.WebSocketServer;
import com.infoloop.tianting.server.message.MessageTypeEnum;
import com.infoloop.tianting.server.message.NoticeTypeEnum;
import com.infoloop.tianting.server.message.SocketMessage;
import com.infoloop.tianting.server.message.data.OrderCreateSuccessData;
import com.infoloop.tianting.server.session.UserTypeEnum;
import com.infoloop.tianting.utils.DateUtil;
import com.infoloop.tianting.utils.JsonUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Nullable;
import java.io.IOException;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderServiceRpcClient {
    private static final String REDIS_KEY_PREFIX = "pickup_code_counter:";
    private final ClientCustomerOrderServiceRpcGrpc.ClientCustomerOrderServiceRpcBlockingStub orderServiceRpcBlockingStub;
    private final MenuServiceRpcClient menuServiceRpcClient;
    private final SkuServiceRpcClient skuServiceRpcClient;
    private final OperatorServiceRpcClient operatorServiceRpcClient;
    private final ClientResourceTagServiceRpcClient clientResourceTagServiceRpcClient;
    private final EnterpriseResourceServiceRpcClient enterpriseResourceServiceRpcClient;
    private final RedissonClient redissonClient;
    private final DelayedQueue<AutoCancelParam> delayedQueue;

    @Nullable
    public SingleClientCustomerOrderRpcResponse getOrderById(Integer orderId) {
        final var clientCustomerOrderById = orderServiceRpcBlockingStub.getClientCustomerOrderById(GetClientCustomerOrderByIdRpcRequest.newBuilder().setId(orderId).build());
        if (!clientCustomerOrderById.hasResponse()) {
            return null;
        }
        return clientCustomerOrderById.getResponse();
    }

    public List<SingleClientCustomerOrderRpcResponse> getOrdersByCustomerId(Integer customerId) {
        return orderServiceRpcBlockingStub.getClientCustomerOrdersByCustomerId(
                GetClientCustomerOrdersByCustomerIdRpcRequest.newBuilder().setCustomerId(customerId).build()).getResponsesList();
    }

    public List<SingleClientCustomerOrderRpcResponse> getOrdersByCondition(QueryOrderByConditionDto queryOrderDto) {
        final var request = QueryClientCustomerOrdersByConditionRpcRequest.newBuilder()
                .setEnterpriseId(queryOrderDto.getEnterpriseId())
                .setShouldFilterOpenIds(queryOrderDto.getShouldFilterOpenId())
                .addAllOpenIds(List.of(queryOrderDto.getOpenId()))
                .setShouldFilterCustomerIds(queryOrderDto.getShouldFilterCustomerIds())
                .addAllCustomerIds(queryOrderDto.getCustomerIds())
                .setShouldFilterMealTimeStart(queryOrderDto.getShouldFilterMealTimeStart())
                .setMealTimeStart(queryOrderDto.getMealTimeStart().toInstant(ZoneOffset.UTC).toEpochMilli())
                .setShouldFilterMealTimeEnd(queryOrderDto.getShouldFilterMealTimeEnd())
                .setMealTimeEnd(queryOrderDto.getMealTimeEnd().toInstant(ZoneOffset.UTC).toEpochMilli())
                .setShouldFilterCreatedAtStart(queryOrderDto.getShouldFilterCreatedAtTimeStart())
                .setCreatedAtStart(queryOrderDto.getCreatedAtTimeStart().toInstant(ZoneOffset.UTC).toEpochMilli())
                .setShouldFilterCreatedAtEnd(queryOrderDto.getShouldFilterCreatedAtTimeEnd())
                .setCreatedAtEnd(queryOrderDto.getCreatedAtTimeEnd().toInstant(ZoneOffset.UTC).toEpochMilli())
                .setShouldFilterClientIds(queryOrderDto.getShouldFilterClientIds())
                .addAllClientIds(queryOrderDto.getClientIds())
                .setShouldFilterStallIds(queryOrderDto.getShouldFilterStallIds())
                .addAllStallIds(queryOrderDto.getStallIds())
                .setShouldFilterStatus(queryOrderDto.getShouldFilterStatus())
                .setStatus(queryOrderDto.getStatus())
                .setShouldFilterMenuIds(queryOrderDto.getShouldFilterMenuId())
                .addAllMenuIds(List.of(queryOrderDto.getMenuId()))
                .setShouldFilterOpenIds(queryOrderDto.getShouldFilterOpenId())
                .addAllOpenIds(List.of(queryOrderDto.getOpenId()))
                .setShouldFilterPayStatus(queryOrderDto.getShouldFilterPayStatus())
                .setPayStatus(queryOrderDto.getPayStatus())
                .setShouldFilterStatues(queryOrderDto.getShouldFilterStatues())
                .addAllStatues(queryOrderDto.getStatues())
                .build();
        return orderServiceRpcBlockingStub.queryClientCustomerOrdersByCondition(request).getResponsesList();
    }

    public UpdateClientCustomerOrderRpcResponse updateClientCustomerOrder(
            UpdateOrderDto updateOrderDto) {
        OrderStatusEnum status = OrderStatusEnum.UNKNOWN_STATUS;
        if (updateOrderDto.isShouldUpdateStatus()) {
            status = updateOrderDto.getStatus();
        }
        String roomNo = "";
        if (updateOrderDto.isShouldUpdateRoomNo()) {
            roomNo = updateOrderDto.getRoomNo();
        }
        String tableCode = "";
        if (updateOrderDto.isShouldUpdateTableCode()) {
            tableCode = updateOrderDto.getTableCode();
        }
        final var modification = ClientCustomerOrderModification.newBuilder()
                .setId(updateOrderDto.getId())
                .setShouldUpdateStatus(updateOrderDto.isShouldUpdateStatus())
                .setStatus(status)
                .setShouldUpdateTableCode(updateOrderDto.isShouldUpdateTableCode())
                .setTableCode(tableCode)
                .setShouldUpdateRoomNo(updateOrderDto.isShouldUpdateRoomNo())
                .setRoomNo(roomNo)
                .setShouldUpdateAvoidRemark(updateOrderDto.getAvoidRemark() != null)
                .setAvoidRemark(updateOrderDto.getAvoidRemark() == null ? "" : updateOrderDto.getAvoidRemark())
                .build();
        final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
                .setEnterpriseId(updateOrderDto.getEnterpriseId())
                .setUpdatedBy(updateOrderDto.getUpdatedBy())
                .setUpdateSource(updateOrderDto.getUpdatedSource())
                .setModification(modification)
                .build();
        final UpdateClientCustomerOrderRpcResponse updateClientCustomerOrderRpcResponse = orderServiceRpcBlockingStub.updateClientCustomerOrder(request);
        if (updateClientCustomerOrderRpcResponse.getIsUpdated() && updateOrderDto.getStatus() != null && updateOrderDto.getStatus() == OrderStatusEnum.ORDER_CANCELED) {
            final var orderById = getOrderById(updateOrderDto.getId());
            if (orderById != null && orderById.getCloseTimeType() == CloseTimeType.IMMEDIATELY) {
                final var orderDetails = getOrderDetailsByOrderId(orderById.getId());
                final var isSuccess = addSkusSellQuantities(orderById.getEnterpriseId(), orderById.getStallId(), orderDetails.stream().map(e -> AddSkusSellQuantityBO.builder()
                        .skuId(e.getSkuId())
                        .quantity(-e.getCount())
                        .build()).collect(Collectors.toList()));
                log.info("Order {} returnSkusSellQuantities result: {}", orderById.getId(), isSuccess);
            }
        }
        return updateClientCustomerOrderRpcResponse;
    }

    public boolean updateClientCustomerOrderCancel(int enterpriseId, int id) {
        final var modification = ClientCustomerOrderModification.newBuilder()
                .setId(id)
                .setShouldUpdateStatus(true)
                .setStatus(OrderStatusEnum.ORDER_CANCELED)
                .setShouldUpdatePayStatus(true)
                .setPayStatus(PayStatusEnum.PAY_CANCELED)
                .build();
        final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .setUpdatedBy(0)
                .setUpdateSource(OrderSourceEnum.STALL)
                .setModification(modification)
                .build();
        return orderServiceRpcBlockingStub.updateClientCustomerOrder(request).getIsUpdated();
    }

    public UpdateClientCustomerOrderRpcResponse updateClientCustomerOrderPaymentResult(SingleClientCustomerOrderRpcResponse order, ClientCustomerOrderModification modification) {
        final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
                .setEnterpriseId(order.getEnterpriseId())
                .setUpdatedBy(order.getCreatedBy())
                .setUpdateSource(order.getCreationSource())
                .setModification(modification)
                .build();
        return orderServiceRpcBlockingStub.updateClientCustomerOrder(request);
    }


    public BatchUpdateClientCustomerOrderDetailsRpcResponse batchUpdateClientCustomerOrderDetails(OrderDetailBatchUpdateDto orderDetailBatchUpdateDto) {
        final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
        final var operator = operatorServiceRpcClient.getCOperatorById(operatorLoginInfo.getId());
        final var idsOfNeedUpdateMenuDetails = new ArrayList<Integer>();
        final var idsOfAddCount = new ArrayList<Integer>();
        final var idsOfNoReject = new ArrayList<Integer>();
        List<OrderDetailDto> originalOrderDetails = new ArrayList<>();
        List<OrderDetailDto> newOrderDetails;
        final var orderDetailsMap = orderDetailBatchUpdateDto.getDetails().stream().collect(Collectors.toMap(OrderDbDTO.OrderDetailUpdateDto::getId, Function.identity()));
        final var modifications = orderDetailBatchUpdateDto.getDetails().stream().map(d -> {
                    var mealDetail = MealDetail.newBuilder().build();
                    Integer menuDetailId = 0;
                    int mealId = 0;
                    int categoryId = 0;
                    int skuId = 0;
                    String showName = "";
                    if (d.getShouldUpdateMenuDetailId()) {
                        idsOfNeedUpdateMenuDetails.add(d.getId());
                        menuDetailId = d.getMenuDetailId();
                        final var menuDetail = menuServiceRpcClient.getMenuDetailById(operatorLoginInfo.getEnterpriseId(), menuDetailId).getResponse();
                        mealId = menuDetail.getMealId();
                        categoryId = menuDetail.getCategoryId();
                        skuId = menuDetail.getSkuId();
                        showName = menuDetail.getShowName();
                        final var rpcSkus = skuServiceRpcClient.getDishSkusByIds(List.of(skuId)).getResponseList();
                        if (!rpcSkus.isEmpty()) {
                            final var skus = rpcSkus.get(0).getSkusList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                            final var skuAvoids = rpcSkus.get(0).getAvoidsList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                            final var tastes = rpcSkus.get(0).getTastesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                            final var efficacies = rpcSkus.get(0).getEfficaciesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                            final var allergies = rpcSkus.get(0).getAllergiesList().stream().map(SingleSpecialResponse::getName).collect(Collectors.toList());
                            final var skuDoctors = rpcSkus.get(0).getDoctorsList().stream().map(SingleSpecialResponse::getName).collect(Collectors.toList());
                            mealDetail = MealDetail.newBuilder()
                                    .setBasicMaterials(rpcSkus.get(0).getBasicMaterials())
                                    .addAllTastes(tastes)
                                    .addAllEfficacies(efficacies)
                                    .addAllDockers(skuDoctors)
                                    .setEnergy(rpcSkus.get(0).getEnergy())
                                    .setFat(rpcSkus.get(0).getFat())
                                    .setProtein(rpcSkus.get(0).getProtein())
                                    .setCarbohydrate(rpcSkus.get(0).getCarbohydrate())
                                    .addAllAllergies(allergies)
                                    .addAllAvoids(skuAvoids)
                                    .addAllSkus(skus)
                                    .build();
                        }
                    }
                    ServeStatusEnum serveStatus = ServeStatusEnum.UNKNOWN_SERVE_STATUS;
                    if (d.getShouldUpdateServeStatus()) {
                        if (d.getServeStatus() == ServeStatusEnum.SERVE_REJECT) {
                            idsOfNoReject.add(d.getId());
                        }
                        serveStatus = d.getServeStatus();
                    }
                    Integer count = 0;
                    if (d.getShouldUpdateCount()) {
                        idsOfAddCount.add(d.getId());
                        count = d.getCount();
                    }
                    return ClientCustomerOrderDetailModification.newBuilder()
                            .setId(d.getId())
                            .setShouldUpdateMenuDetailId(d.getShouldUpdateMenuDetailId())
                            .setMenuDetailId(menuDetailId)
                            .setShouldUpdateCount(d.getShouldUpdateCount())
                            .setCount(count)
                            .setShouldUpdateMealId(d.getShouldUpdateMenuDetailId())
                            .setMealId(mealId)
                            .setShouldUpdateCategoryId(d.getShouldUpdateMenuDetailId())
                            .setCategoryId(categoryId)
                            .setShouldUpdateSkuId(d.getShouldUpdateMenuDetailId())
                            .setSkuId(skuId)
                            .setShouldUpdateShowName(d.getShouldUpdateMenuDetailId())
                            .setShowName(showName)
                            .setShouldUpdateServeStatus(d.getShouldUpdateServeStatus())
                            .setServeStatus(serveStatus)
                            .setShouldUpdateMealDetailJson(d.getShouldUpdateMenuDetailId())
                            .setMealDetailJson(mealDetail)
                            .build();
                }
        ).collect(Collectors.toList());
        final var request = BatchUpdateClientCustomerOrderDetailsRpcRequest.newBuilder()
                .setEnterpriseId(operatorLoginInfo.getEnterpriseId())
                .setUpdatedBy(operatorLoginInfo.getId())
                .setUpdateSourceValue(orderDetailBatchUpdateDto.getUpdatedSource().getNumber())
                .addAllModifications(modifications)
                .build();
        final var totalIds = new ArrayList<>(idsOfNeedUpdateMenuDetails);
        totalIds.addAll(idsOfAddCount);
        totalIds.addAll(idsOfNoReject);
        if (!totalIds.isEmpty()) {
            final var orgionalResponseList = getClientCustomerOrderDetailsByIds(totalIds);
            originalOrderDetails = orgionalResponseList.stream().map(d -> OrderDetailDto.builder()
                    .id(d.getId())
                    .count(d.getCount())
                    .categoryId(d.getCategoryId())
                    .mealId(d.getMealId())
                    .menuDetailId(d.getMenuDetailId())
                    .orderId(d.getOrderId())
                    .price(d.getPrice())
                    .showName(d.getShowName())
                    .mealDetailJson(MealDetailDto.builder()
                            .allergies(d.getMealDetailJson().getAllergiesList())
                            .basicMaterials(d.getMealDetailJson().getBasicMaterials())
                            .dockers(d.getMealDetailJson().getDockersList())
                            .efficacies(d.getMealDetailJson().getEfficaciesList())
                            .fat(d.getMealDetailJson().getFat())
                            .tastes(d.getMealDetailJson().getTastesList())
                            .protein(d.getMealDetailJson().getProtein())
                            .carbohydrate(d.getMealDetailJson().getCarbohydrate())
                            .energy(d.getMealDetailJson().getEnergy())
                            .avoids(d.getMealDetailJson().getAvoidsList())
                            .skus(d.getMealDetailJson().getSkusList())
                            .build())
                    .adjustSkuRemark(d.getAdjustSkuRemark())
                    .enterpriseId(d.getEnterpriseId())
                    .skuId(d.getSkuId())
                    .serveStatus(d.getServeStatus())
                    .creationSource(d.getCreationSource().getNumber())
                    .createdBy(d.getCreatedBy())
                    .createdAt(DateUtil.formatDate(d.getCreatedAt()))
                    .updateSource(d.getUpdateSource().getNumber())
                    .updatedAt(DateUtil.formatDate(d.getUpdatedAt()))
                    .updatedBy(d.getUpdatedBy())
                    .build()).collect(Collectors.toList());
        }
        final var res = orderServiceRpcBlockingStub.batchUpdateClientCustomerOrderDetails(request);
        if (res.getIsUpdated()) {
            if (!totalIds.isEmpty()) {
                final var newResponseList = getClientCustomerOrderDetailsByIds(totalIds);
                newOrderDetails = newResponseList.stream().map(d ->
                        OrderDetailDto.builder()
                                .id(d.getId())
                                .count(d.getCount())
                                .categoryId(d.getCategoryId())
                                .mealId(d.getMealId())
                                .menuDetailId(d.getMenuDetailId())
                                .orderId(d.getOrderId())
                                .price(d.getPrice())
                                .showName(d.getShowName())
                                .mealDetailJson(MealDetailDto.builder()
                                        .allergies(d.getMealDetailJson().getAllergiesList())
                                        .basicMaterials(d.getMealDetailJson().getBasicMaterials())
                                        .dockers(d.getMealDetailJson().getDockersList())
                                        .efficacies(d.getMealDetailJson().getEfficaciesList())
                                        .fat(d.getMealDetailJson().getFat())
                                        .tastes(d.getMealDetailJson().getTastesList())
                                        .protein(d.getMealDetailJson().getProtein())
                                        .carbohydrate(d.getMealDetailJson().getCarbohydrate())
                                        .energy(d.getMealDetailJson().getEnergy())
                                        .avoids(d.getMealDetailJson().getAvoidsList())
                                        .skus(d.getMealDetailJson().getSkusList())
                                        .build())
                                .adjustSkuRemark(d.getAdjustSkuRemark())
                                .enterpriseId(d.getEnterpriseId())
                                .skuId(d.getSkuId())
                                .serveStatus(d.getServeStatus())
                                .creationSource(d.getCreationSource().getNumber())
                                .createdBy(d.getCreatedBy())
                                .createdAt(DateUtil.formatDate(d.getCreatedAt()))
                                .updateSource(d.getUpdateSource().getNumber())
                                .updatedAt(DateUtil.formatDate(d.getUpdatedAt()))
                                .updatedBy(d.getUpdatedBy())
                                .build()).toList();
                // 替换菜品的操作记录
                List<SingleOperationDto> operations = new ArrayList<>();
                for (OrderDetailDto originalDetail : originalOrderDetails) {
                    if (!totalIds.contains(originalDetail.getId())) {
                        continue;
                    }
                    final var orderDetailUpdateDto = orderDetailsMap.get(originalDetail.getId());
                    OrderOperationType orderOperationType = OrderOperationType.UNKNOWN_OPERATION_TYPE;
                    if (idsOfNeedUpdateMenuDetails.contains(originalDetail.getId())) {
                        orderOperationType = OrderOperationType.REPLACE_DISHES;
                    } else if (idsOfAddCount.contains(originalDetail.getId())) {
                        orderOperationType = OrderOperationType.ADD_DISHES;
                    } else if (idsOfNoReject.contains(originalDetail.getId())) {
                        orderOperationType = OrderOperationType.NOT_SERVE;
                    }
                    String originalDetailStr;
                    String newDetailStr = "";
                    final var newDetail = newOrderDetails.stream().filter(n -> n.getId().equals(originalDetail.getId())).findFirst();
                    if (newDetail.isPresent()) {
                        final var newOrderDetailOperation = OrderDetailOperationDto.builder()
                                .id(newDetail.get().getId())
                                .skuId(newDetail.get().getSkuId())
                                .skuName(newDetail.get().getShowName())
                                .count(newDetail.get().getCount())
                                .adjustSkuRemark(newDetail.get().getAdjustSkuRemark())
                                .serveStatus(newDetail.get().getServeStatus().name())
                                .price(orderDetailUpdateDto.getPrice() == null ? newDetail.get().getPrice() : orderDetailUpdateDto.getPrice())
                                .build();
                        newDetailStr = JsonUtil.writeAsJson(List.of(newOrderDetailOperation));
                    }
                    final var originalOrderDetailOperation = OrderDetailOperationDto.builder()
                            .id(originalDetail.getId())
                            .skuId(originalDetail.getSkuId())
                            .skuName(originalDetail.getShowName())
                            .count(originalDetail.getCount())
                            .adjustSkuRemark(originalDetail.getAdjustSkuRemark())
                            .serveStatus(originalDetail.getServeStatus().name())
                            .price(originalDetail.getPrice())
                            .build();
                    originalDetailStr = JsonUtil.writeAsJson(List.of(originalOrderDetailOperation));
                    final var operation = SingleOperationDto.builder()
                            .orderId(originalDetail.getOrderId())
                            .shouldCreateAdjustOrderDetailJson(true)
                            .shouldCreateOriginalOrderDetailJson(true)
                            .shouldCreateAdjustOrderJson(false)
                            .shouldCreateOriginalOrderJson(false)
                            .adjustOrderDetailJson(newDetailStr)
                            .originalOrderDetailJson(originalDetailStr)
                            .type(orderOperationType)
                            .build();
                    operations.add(operation);
                }
                final var batchOperations = BatchOperationDto.builder()
                        .createdBy(operatorLoginInfo.getId())
                        .creationSource(OrderSourceEnum.STALL)
                        .enterpriseId(operatorLoginInfo.getEnterpriseId())
                        .operator(operator.getName())
                        .creations(operations)
                        .build();
                batchCreateOrderOperationRecords(batchOperations);
            }
        }
        return res;
    }

    public BatchCreateOrderOperationRecordsResponse batchCreateOrderOperationRecords(BatchOperationDto batchOperationDto) {
        final var request = BatchCreateOrderOperationRecordsRequest.newBuilder()
                .addAllCreations(batchOperationDto.getCreations().stream().map(c ->
                        OrderOperationRecordCreation.newBuilder()
                                .setOrderId(c.getOrderId())
                                .setShouldCreateAdjustOrderJson(c.isShouldCreateAdjustOrderJson())
//                .setAdjustOrderJson(c.getAdjustOrderJson())
                                .setShouldCreateOriginalOrderJson(c.isShouldCreateOriginalOrderJson())
//                .setOriginalOrderJson(c.getOriginalOrderJson())
                                .setShouldCreateAdjustOrderDetailJson(c.isShouldCreateAdjustOrderDetailJson())
                                .setAdjustOrderDetailJson(c.getAdjustOrderDetailJson())
                                .setShouldCreateOriginalOrderDetailJson(c.isShouldCreateOriginalOrderDetailJson())
                                .setOriginalOrderDetailJson(c.getOriginalOrderDetailJson())
                                .setType(c.getType())
                                .build()).collect(Collectors.toList()))
                .setCreatedBy(batchOperationDto.getCreatedBy())
                .setEnterpriseId(batchOperationDto.getEnterpriseId())
                .setOperator(batchOperationDto.getOperator())
                .setCreationSource(batchOperationDto.getCreationSource())
                .build();
        return orderServiceRpcBlockingStub.batchCreateOrderOperationRecords(request);
    }

    public QueryClientCustomerOrdersByPaginationRpcResponse queryClientCustomerOrdersByPagination(QueryOrderByPaginationDto queryOrderDto) {
        final var request = QueryClientCustomerOrdersByPaginationRpcRequest.newBuilder()
                .setKeyword(queryOrderDto.getKeyword() == null ? "" : queryOrderDto.getKeyword())
                .setPageNo(queryOrderDto.getPn())
                .setPageSize(queryOrderDto.getPz())
                .setShouldFilterStatus(true)
                .setShouldFilterPayStatus(false)
                .setStatus(queryOrderDto.getStatus())
                .setEnterpriseId(queryOrderDto.getEnterpriseId())
                .setClientId(queryOrderDto.getClientId())
                .addAllStallIds(queryOrderDto.getStallIds())
                .build();
        return orderServiceRpcBlockingStub.queryClientCustomerOrdersByPagination(request);
    }

    public GetOrderOperationRecordsByOrderIdsResponse getOrderOperationRecordsByOrderIds(int enterpriseId, List<Integer> orderIds) {
        final var request = GetOrderOperationRecordsByOrderIdsRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .addAllOrderIds(orderIds)
                .build();
        return orderServiceRpcBlockingStub.getOrderOperationRecordsByOrderIds(request);
    }

    public QueryClientCustomerOrdersByConditionRpcResponse queryClientCustomerOrdersByCondition(OrderDbDTO.QueryOrderDto queryOrderDto) {
        final var request = QueryClientCustomerOrdersByConditionRpcRequest.newBuilder()
                .setShouldFilterStatus(true)
                .setStatus(queryOrderDto.getStatus())
                .setEnterpriseId(queryOrderDto.getEnterpriseId())
                .setShouldFilterClientIds(true).addClientIds(queryOrderDto.getClientId())
                .setShouldFilterStallIds(true).addAllStallIds(queryOrderDto.getStallIds());
        if (StringUtils.isNotEmpty(queryOrderDto.getMealTime())) {
            LocalDate today = LocalDate.parse(queryOrderDto.getMealTime(), DateUtil.YYYY_MM_DD);
            LocalDateTime todayZero = today.atStartOfDay();
            LocalDateTime todayEnd = today.atTime(LocalTime.MAX);
            request.setShouldFilterMealTimeStart(true)
                    .setMealTimeStart(todayZero.toInstant(ZoneOffset.UTC).toEpochMilli())
                    .setShouldFilterMealTimeEnd(true)
                    .setMealTimeEnd(todayEnd.toInstant(ZoneOffset.UTC).toEpochMilli());
        }
        return orderServiceRpcBlockingStub.queryClientCustomerOrdersByCondition(request.build());
    }

    public QueryClientCustomerOrdersByPaginationRpcResponse queryRefundClientCustomerOrdersByPagination(
            QueryRefundOrderByPaginationDto queryOrderDto) {
        final var request = QueryClientCustomerOrdersByPaginationRpcRequest.newBuilder()
                .setKeyword(queryOrderDto.getKeyword() == null ? "" : queryOrderDto.getKeyword())
                .setPageNo(queryOrderDto.getPn())
                .setPageSize(queryOrderDto.getPz())
                .setShouldFilterStatus(false)
                .setShouldFilterPayStatus(true)
                .setPayStatus(PayStatusEnum.REFUND)
                .setEnterpriseId(queryOrderDto.getEnterpriseId())
                .setClientId(queryOrderDto.getClientId())
                .addAllStallIds(queryOrderDto.getStallIds())
                .build();
        return orderServiceRpcBlockingStub.queryClientCustomerOrdersByPagination(request);
    }

    public List<SingleClientCustomerOrderDetailRpcResponse> getOrderDetailsByOrderId(Integer orderId) {
        return orderServiceRpcBlockingStub.getClientCustomerOrderDetailsByOrderIds(
                GetClientCustomerOrderDetailsByOrderIdsRpcRequest.newBuilder()
                        .setIncludeDeleted(false)
                        .addAllOrderIds(List.of(orderId))
                        .build()).getResponsesList();
    }

    public List<SingleClientCustomerOrderDetailRpcResponse> getClientCustomerOrderDetailsByIds(List<Integer> ids) {
        return orderServiceRpcBlockingStub.getClientCustomerOrderDetailsByIds(
                GetClientCustomerOrderDetailsByIdsRpcRequest.newBuilder()
                        .setIncludeDeleted(false)
                        .addAllIds(ids)
                        .build()).getResponsesList();
    }

    public List<SingleClientCustomerOrderDetailRpcResponse> getOrderDetailsByOrderIds(List<Integer> orderIds) {
        return orderServiceRpcBlockingStub.getClientCustomerOrderDetailsByOrderIds(
                GetClientCustomerOrderDetailsByOrderIdsRpcRequest.newBuilder()
                        .setIncludeDeleted(false)
                        .addAllOrderIds(orderIds)
                        .build()).getResponsesList();
    }

    public String generatePickupCode() {
        final var today = LocalDate.now();
        final var currentDate = DateUtil.formatDate(today, DateUtil.YYYY_MM_DD);
        final var redisKey = REDIS_KEY_PREFIX + currentDate;
        final var atomicLong = redissonClient.getAtomicLong(redisKey);
        if (atomicLong.get() == 0) {
            LocalDateTime endOfDay = today.atTime(23, 59, 59, 999999999);
            long millisUntilEndOfDay = Duration.between(LocalDateTime.now(), endOfDay).toMillis();
            atomicLong.expire(Duration.ofMillis(millisUntilEndOfDay));
        }
        final var counter = atomicLong.incrementAndGet();
        return String.format("%04d", (int) counter);
    }

    public CreateOrderResponse createOrder(CreateOrderDto createOrderDto) {
        final var orderDetails = new ArrayList<ClientCustomerOrderDetailCreation>();
        for (final var orderDetailDto : createOrderDto.getOrderDetailDtos()) {
            final var mealDetail = MealDetail.newBuilder()
                    .setBasicMaterials(orderDetailDto.getMealDetailJson().getBasicMaterials())
                    .addAllTastes(orderDetailDto.getMealDetailJson().getTastes())
                    .addAllEfficacies(orderDetailDto.getMealDetailJson().getEfficacies())
                    .addAllDockers(orderDetailDto.getMealDetailJson().getDockers())
                    .setEnergy(orderDetailDto.getMealDetailJson().getEnergy())
                    .setFat(orderDetailDto.getMealDetailJson().getFat())
                    .setProtein(orderDetailDto.getMealDetailJson().getProtein())
                    .setCarbohydrate(orderDetailDto.getMealDetailJson().getCarbohydrate())
                    .addAllAllergies(orderDetailDto.getMealDetailJson().getAllergies())
                    .addAllAvoids(orderDetailDto.getMealDetailJson().getAvoids())
                    .addAllSkus(orderDetailDto.getMealDetailJson().getSkus())
                    .build();
            final var orderDetail = ClientCustomerOrderDetailCreation.newBuilder()
                    .setMenuDetailId(orderDetailDto.getMenuDetailId())
                    .setShouldCreateOrderId(false)
                    .setOrderId(0)
                    .setCount(orderDetailDto.getCount())
                    .setMealId(orderDetailDto.getMealId())
                    .setCategoryId(orderDetailDto.getCategoryId())
                    .setShouldCreateShowName(true)
                    .setShowName(orderDetailDto.getShowName())
                    .setPrice(orderDetailDto.getPrice())
                    .setMealDetailJson(mealDetail)
                    .setServeStatus(ServeStatusEnum.SERVE_NOT_START)
                    .setShouldCreatePrice(true)
                    .setShouldCreateMealDetailJson(true)
                    .setSkuId(orderDetailDto.getSkuId())
                    .build();
            orderDetails.add(orderDetail);
        }
        final var customerNotice = CustomerNotice.newBuilder()
                .addAllAvoids(createOrderDto.getCustomerNoticeJson().getAvoids())
                .addAllDoctors(createOrderDto.getCustomerNoticeJson().getDoctors())
                .build();
        final var menuById = menuServiceRpcClient.getMenuById(createOrderDto.getEnterpriseId(), createOrderDto.getMenuId());
        OrderStatusEnum orderStatus = OrderStatusEnum.TO_PREPARE;
        if (createOrderDto.getOnlinePay() != OnlinePayEnum.ONLINE) {
            var orderRuleJson = menuById.getResponse().getOrderRuleJson();
            if (orderRuleJson.getModeOfPayment() != ModeOfPaymentEnum.ONLINE && orderRuleJson.getCloseTimeType() == CloseTimeTypeEnum.IMMEDIATELY) {
                orderStatus = OrderStatusEnum.PREPARING;
            }
        }
        final var creation = ClientCustomerOrderCreation.newBuilder()
                .setShouldCreateCustomerId(createOrderDto.getShouldCreateCustomerId())
                .setShouldCreateCustomerId(true).setCustomerId(createOrderDto.getCustomerId())
                .setStallId(createOrderDto.getStallId())
                .setStatus(createOrderDto.getStatus() == null ? orderStatus : createOrderDto.getStatus())
                .setAddress(createOrderDto.getAddress())
                .setClientId(createOrderDto.getClientId())
                .setShouldCreateOpenId(!LoginContextHolder.getOpenId().isEmpty()).setOpenId(LoginContextHolder.getOpenId())
                .setShouldCreateRoomNo(!createOrderDto.getRoomNo().isEmpty()).setRoomNo(createOrderDto.getRoomNo())
                .setShouldCreateTableCode(createOrderDto.getCloseTimeType().equals(CloseTimeType.IMMEDIATELY) || StringUtils.isNotEmpty(createOrderDto.getTableCode())).setTableCode(createOrderDto.getTableCode() == null ? "" : createOrderDto.getTableCode())
                .setShouldCreateOnlinePay(true).setOnlinePay(createOrderDto.getOnlinePay())
                .setShouldCreatePayStatus(true).setPayStatus(createOrderDto.getOnlinePay() == OnlinePayEnum.ONLINE ? PayStatusEnum.TO_PAY : PayStatusEnum.SUCCEED)
                .setMenuId(createOrderDto.getMenuId())
                .setTotalNum(createOrderDto.getTotalNum())
                .setShouldCreatePayPrice(createOrderDto.getOnlinePay() == OnlinePayEnum.LEAVE_HOSPITAL).setPayPrice(createOrderDto.getPayPrice())
                .setMealTime(createOrderDto.getMealTime().toLocalDate().atStartOfDay().toEpochSecond(ZoneOffset.ofHours(8)) * 1000)
                .setShouldCreatePickupCode(createOrderDto.getCloseTimeType().equals(CloseTimeType.IMMEDIATELY)).setPickupCode(generatePickupCode())
                .setShouldCreateOrderType(true).setOrderType(menuById.getResponse().getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.RESERVATION ? OrderTypeEnum.DELIVERY : OrderTypeEnum.DINE_IN)
                .setShouldCreateRemark(true).setRemark(createOrderDto.getRemark())
                .setShouldCreateCustomerNoticeJson(true).setCustomerNoticeJson(customerNotice)
                .setCloseTimeType(createOrderDto.getCloseTimeType())
                .setShouldCreateOrderDetails(true).addAllOrderDetails(orderDetails)
                .build();
        log.info("createOrder mealTime:{}", createOrderDto.getMealTime());

        if (menuById.getResponse().getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.IMMEDIATELY) {
            final var skuIds = createOrderDto.getOrderDetailDtos().stream().map(CreateOrderDetailDto::getSkuId).collect(Collectors.toList());
            final var skuSellQuantities = this.querySkuSellQuantitiesByStallAndSkuIds(createOrderDto.getEnterpriseId(), createOrderDto.getStallId(), skuIds);
            final var skuSellQuantityMap = skuSellQuantities.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
            final var skuMap = skuServiceRpcClient.getSkusByIds(skuIds).stream().collect(Collectors.toMap(SingleSkuResponse::getId, Function.identity()));
            final var skuStockMap = new HashMap<String, Integer>();
            for (var orderDetail : createOrderDto.getOrderDetailDtos()) {
                final var skuSellQuantityRpcResponse = skuSellQuantityMap.get(orderDetail.getSkuId());
                if (skuSellQuantityRpcResponse == null) {
                    continue;
                }
                if ((skuSellQuantityRpcResponse.getTodaySellQuantity() + orderDetail.getCount()) > skuSellQuantityRpcResponse.getMaxSellQuantity()) {
                    log.error("skuSellQuantityRpcResponse stock no enough; stallId:{}, skuId:{}, count:{}", createOrderDto.getStallId(), orderDetail.getSkuId(), orderDetail.getCount());
                    skuStockMap.put(skuMap.get(orderDetail.getSkuId()).getName(), skuSellQuantityRpcResponse.getMaxSellQuantity() - skuSellQuantityRpcResponse.getTodaySellQuantity());
                }
            }
            if (!skuStockMap.isEmpty()) {
                final var noEnoughSkus = String.join(", ", skuStockMap.keySet());
                throw ClientEndExceptions.BusinessException.build(ErrorCodeEnum.SKUS_STOCK_NO_ENOUGH_TODAY, noEnoughSkus);
            }
        }
        final var orderResponse = orderServiceRpcBlockingStub.createClientCustomerOrder(CreateClientCustomerOrderRpcRequest.newBuilder()
                .setCreation(creation)
                .setCreationSource(OrderSourceEnum.forNumber(createOrderDto.getCreationSource()))
                .setEnterpriseId(createOrderDto.getEnterpriseId())
                .setCreatedBy(createOrderDto.getCreatedBy())
                .build());
        if (orderResponse.getIsCreated()) {
            // 用餐时间为当天，并且非在线支付餐单，发送消息给客户端
            if (createOrderDto.getMealTime().toLocalDate().equals(LocalDate.now()) && menuById.getResponse().getOrderRuleJson().getModeOfPayment() != ModeOfPaymentEnum.ONLINE) {
                final var orderCreateSuccessData = OrderCreateSuccessData.builder()
                        .orderId(orderResponse.getId())
                        .build();
                final var data = SocketMessage.<OrderCreateSuccessData>builder()
                        .type(MessageTypeEnum.ORDER)
                        .noticeType(NoticeTypeEnum.ORDER_CREATED)
                        .subject(NoticeTypeEnum.ORDER_CREATED.getDescription())
                        .message("有新的订单下单成功啦，快去查看吧～")
                        .data(orderCreateSuccessData)
                        .build();
                final var clientOperatorIds = clientResourceTagServiceRpcClient.getOperatorIdsByStallIds(List.of(createOrderDto.getStallId())).stream().map(SingleResourceLabelEntityRefsResponse::getEntityId).distinct().collect(Collectors.toList());
                final var enterpriseOperatorIds = enterpriseResourceServiceRpcClient.getOperatorIdsByStallId(createOrderDto.getEnterpriseId(), createOrderDto.getStallId());
                final var userAuthData = new ArrayList<UserAuthData>();
                userAuthData.addAll(clientOperatorIds.stream().map(e -> UserAuthData.builder().operatorId(e).userType(UserTypeEnum.CLIENT).build()).collect(Collectors.toList()));
                userAuthData.addAll(enterpriseOperatorIds.stream().map(e -> UserAuthData.builder().operatorId(e).userType(UserTypeEnum.KDS).build()).collect(Collectors.toList()));
                log.info("received userAuthData:{}", JsonUtil.writeAsJson(userAuthData));
                try {
                    WebSocketServer.sendMessageByUserTypes(List.of(UserTypeEnum.CLIENT, UserTypeEnum.KDS), userAuthData, data);
                } catch (IOException e) {
                    log.error("Failed to send message to user", e);
                }
            }
            //立即点餐需要扣除库存
            if (menuById.getResponse().getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.IMMEDIATELY) {
                final var isSuccess = this.addSkusSellQuantities(createOrderDto.getEnterpriseId(), createOrderDto.getStallId(),
                        orderDetails.stream().map(e -> AddSkusSellQuantityBO.builder()
                                .skuId(e.getSkuId())
                                .quantity(e.getCount())
                                .build()).collect(Collectors.toList()));
                log.info("Order {} addSkusSellQuantities result: {}", orderResponse.getId(), isSuccess);
            }
            //在线支付需要延迟取消订单
            if (menuById.getResponse().getOrderRuleJson().getModeOfPayment() == ModeOfPaymentEnum.ONLINE) {
                final var autoCancelParam = new AutoCancelParam();
                autoCancelParam.setOrderId(orderResponse.getId());
                delayedQueue.addToQueue(OrderAutoCancelDelayTask.AUTO_CANCEL_ORDER_DELAY_QUEUE, autoCancelParam, 10, TimeUnit.MINUTES);
            }
        }
        return CreateOrderResponse.builder().id(orderResponse.getId()).isCreated(true).build();
    }

    public boolean batchUpdateClientCustomerOrders(LoginContextHolder.LoginInfo loginInfo, List<ClientCustomerOrderModification> modifications) {
        return orderServiceRpcBlockingStub.batchUpdateClientCustomerOrders(BatchUpdateClientCustomerOrdersRpcRequest.newBuilder()
                .setEnterpriseId(loginInfo.getEnterpriseId())
                .setUpdatedBy(loginInfo.getId())
                .setUpdateSource(OrderSourceEnum.forNumber(loginInfo.getLoginSource().getValue()))
                .addAllModifications(modifications)
                .build()).getIsUpdated();
    }


    public List<SingleSkuSellQuantityRpcResponse> querySkuSellQuantitiesByStall(int enterpriseId, int stallId) {
        return orderServiceRpcBlockingStub.querySkuSellQuantitiesByStall(QuerySkuSellQuantitiesByStallRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .setStallId(stallId)
                .build()).getResponsesList();
    }

    public List<SingleSkuSellQuantityRpcResponse> querySkuSellQuantitiesByStallAndSkuIds(int enterpriseId, int stallId, List<Integer> skuIds) {
        return orderServiceRpcBlockingStub.querySkuSellQuantitiesByStallAndSkuIds(QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .setStallId(stallId)
                .addAllSkuIds(skuIds)
                .build()).getResponsesList();
    }

    public boolean batchSaveSkuSellQuantities(int enterpriseId, int stallId, List<SkuSellQuantityBO> skuSellQuantityBOs) {
        return orderServiceRpcBlockingStub.batchSaveSkuSellQuantities(BatchSaveSkuSellQuantitiesRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .setUpdatedBy(stallId)
                .addAllSkuSellQuantityModifications(skuSellQuantityBOs.stream().map(e -> SkuSellQuantityModification.newBuilder()
                        .setId(e.getId() == null ? 0 : e.getId())
                        .setStallId(stallId)
                        .setSkuId(e.getSkuId())
                        .setMaxSellQuantity(e.getMaxSellQuantity())
                        .build()).collect(Collectors.toList()))
                .build()).getIsSaved();
    }

    public boolean addSkusSellQuantities(int enterpriseId, int stallId, List<AddSkusSellQuantityBO> skuSellQuantityBOs) {
        return orderServiceRpcBlockingStub.addSkusSellQuantities(AddSkusSellQuantitiesRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .setStallId(stallId)
                .addAllSkuSellQuantities(skuSellQuantityBOs.stream().map(e -> SkuSellQuantity.newBuilder()
                        .setSkuId(e.getSkuId())
                        .setQuantity(e.getQuantity())
                        .build()).collect(Collectors.toList()))
                .build()).getIsAdded();
    }

    public boolean releaseSkusSellQuantities(int enterpriseId) {
        return orderServiceRpcBlockingStub.releaseSkusSellQuantities(ReleaseSkusSellQuantitiesRpcRequest.newBuilder()
                .setEnterpriseId(enterpriseId)
                .build()).getIsReleased();
    }

}