package com.zy.asrs.task;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.R;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.OrderSyncHandler;
import com.zy.asrs.utils.OrderInAndOutUtil;
import com.zy.common.entity.Parameter;
import com.zy.common.model.LocDto;
import com.zy.common.model.TaskDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.*;

/**
 * updated by IX in 2024/12/17
 */
@Slf4j
@Component
public class OrderSyncScheduler {

    @Autowired
    private OrderSyncHandler orderSyncHandler;
    @Autowired
    private OrderService orderService;
    @Autowired
    private ApiLogService apiLogService;

    @Value("${erp.switch.ErpReportOld}")
    private boolean ErpReportOld;
    @Autowired
    private OrderPakoutService orderPakoutService;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private OrderDetlPakoutService orderDetlPakoutService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private WorkService workService;
    @Autowired
    private LocAroundBindService locAroundBindService;

    @Scheduled(cron = "0 0 1 * * ? ")
    public void clearApiLog() {
        try {
            apiLogService.clearWeekBefore();
        } catch (Exception e) {
            log.error("第三方接口日志自动清除失败（范围：一周之前", e);
        }
    }


    @Scheduled(cron = "0/30 * * * * ? ")
    public void checkOrderPakoutSettled() {
        List<OrderPakout> list = orderPakoutService.selectBySettle(1L);
        if (Cools.isEmpty(list)) {
            return;
        }
        for (OrderPakout order : list) {
            if (order.getDocType() != null) {
                DocType docType = docTypeService.selectById(order.getDocType());
                if (docType != null && Integer.valueOf(1).equals(docType.getPakout())) {
                    List<LocDto> locDtos = new ArrayList<>();
                    Set<String> exist = new HashSet<>();
                    Boolean flag = false;
                    // 获取该订单中订单明细里的id
                    List<OrderDetlPakout> detls = orderDetlPakoutService.selectByOrderId(order.getId());
                    if (!Cools.isEmpty(detls)) {
                        for (OrderDetlPakout detl : detls) {

                            double issued = Optional.of(detl.getAnfme() - detl.getWorkQty()).orElse(0.0D);
                            if (issued <= 0.0D) {
                                continue;
                            }
                            List<LocDetl> locDetls = locDetlService.queryStockAll(null, exist, detl.getMatnr(), detl.getBatch(),
                                    detl.getBrand(), detl.getStandby1(), detl.getStandby2(), detl.getStandby3(), detl.getBoxType1(), detl.getBoxType2(), detl.getBoxType3());
                            for (LocDetl locDetl : locDetls) {
                                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetl.getLocNo()).eq("loc_sts","F"));
                                if (locMast != null) {
                                    LocAroundBind bLocNo = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", locMast.getLocNo()));
                                    if (!Cools.isEmpty(bLocNo)) {
                                        continue;
                                    }
                                }
                                if (issued > 0) {
                                    LocDto locDto = new LocDto(locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getMaktx(), locDetl.getBatch(), detl.getOrderNo(),
                                            issued >= locDetl.getAnfme() ? locDetl.getAnfme() : issued);
//                                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetl.getLocNo()));
                                    locDto.setFrozen(locDetl.getFrozen());
                                    locDto.setFrozenLoc(locMast.getFrozen());
                                    List<Integer> staNos = staDescService.queryOutStaNosByLocNo(locDetl.getLocNo(), issued >= locDetl.getAnfme() ? 101 : 103);
                                    locDto.setStaNos(staNos);
                                    locDto.setBrand(detl.getBrand());
                                    locDto.setStandby1(detl.getStandby1());
                                    locDto.setStandby2(detl.getStandby2());
                                    locDto.setStandby3(detl.getStandby3());
                                    locDto.setBoxType1(detl.getBoxType1());
                                    locDto.setBoxType2(detl.getBoxType2());
                                    locDto.setBoxType3(detl.getBoxType3());
                                    locDtos.add(locDto);
                                    exist.add(locDetl.getLocNo());
                                    // 剩余待出数量递减
                                    issued = issued - locDetl.getAnfme();
                                } else {

                                    break;
                                }
                            }
                            if (issued > 0) {
                                flag = true;
                                break;
                            }
                        }
                        if (flag) {
                            continue;
                        }
                        List<TaskDto> taskDtos = new ArrayList<>();
                        // 根据 （库位 & 出库站） 分组； 理想状态：一组为一次出库任务
                        for (LocDto locDto : locDtos) {
                            if (locDto.isLack()) { continue; }
                            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getStaNo(), locDto, locDto.getStandby1());
                            if (TaskDto.has(taskDtos, taskDto)) {
                                TaskDto dto = TaskDto.find(taskDtos, taskDto);
                                assert dto != null;
                                dto.getLocDtos().addAll(taskDto.getLocDtos());
                            } else {
                                taskDtos.add(taskDto);
                            }
                        }
                        // -----------------------------------------------------------------------------------------------
                        for (TaskDto taskDto : taskDtos) {
                            BasDevp staNo = basDevpService.checkSiteStatus(taskDto.getStaNo());
                            if (!Objects.isNull(taskDto.getDeviceNo())) {
                                //生成出库任务
                                workService.stockOut(staNo, taskDto, taskDto.getDeviceNo(), 9995L);
                            } else  {
                                workService.stockOut(staNo, taskDto, null, 9995L);
                            }
                        }
                    }
                }
            }
        }
    }


    //    @Scheduled(cron = "0/5 * * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderInAndOutUtil() {
//        String erpReport = Parameter.get().getErpReport();
//        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
        List<Order> orders = OrderInAndOutUtil.selectComplete(null);
        for (Order order : orders) {
            try {
                ReturnT<String> result = orderSyncHandler.startOrderInAndOutUtil(order);
                if (!result.isSuccess()) {
                    log.error("单据[orderNo={}]转上报表失败", order.getOrderNo());
                }
            } catch (Exception e) {
                log.error(e.getMessage());
                log.error("单据[orderNo={}]转上报表失败", order.getOrderNo());
            }
        }
//        }
    }

    //    @Scheduled(cron = "0/30 * * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderReport() {
        if (!ErpReportOld) {
            return;
        }
        String erpReport = Parameter.get().getErpReport();
        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<Order> orders = orderService.selectComplete();
            for (Order order : orders) {
                try {
                    ReturnT<String> result = orderSyncHandler.startOrderReport(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                    }
                } catch (Exception e) {
                    log.error(e.getMessage());
                    log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                }
            }
        }
    }
}