package com.yuanchu.mom.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yuanchu.mom.mapper.ManualTechnologyMapper;
import com.yuanchu.mom.mapper.ManufactureOrderMapper;
import com.yuanchu.mom.pojo.*;
import com.yuanchu.mom.pojo.dto.ManualTechnologyDto;
import com.yuanchu.mom.pojo.dto.ManualTechnologyDto1;
import com.yuanchu.mom.service.ManualTechnologyService;
import com.yuanchu.mom.service.ManufactureOrderProcessService;
import com.yuanchu.mom.service.ManufactureSchedulingService;
import com.yuanchu.mom.utils.MyUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 编制工序表(ManualTechnology)表服务实现类
 *
 * @author zss
 * @since 2023-08-17 14:16:46
 */
@Service
public class ManualTechnologyServiceImpl extends ServiceImpl<ManualTechnologyMapper, ManualTechnology> implements ManualTechnologyService {

    @Resource
    ManualTechnologyMapper manualTechnologyMapper;

    @Resource
    ManufactureOrderMapper manufactureOrderMapper;

    @Autowired
    private ManufactureSchedulingService manufactureSchedulingService;

    @Autowired
    private ManufactureOrderProcessService manufactureOrderProcessService;

    //排产-->查看
    @Override
    public List<Map<String, Object>> seleDatil(Integer manOrdId) {
        return manualTechnologyMapper.seleDatil(manOrdId);
    }

    //排产-->更新
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void output(ManualTechnologyDto manualTechnologyDto) throws ParseException {

        // 根据排产数量计算工艺周期
        List<ManufactureOrderProcess> manufactureOrderProcessesPeriod = matchingCycle(
                manualTechnologyDto.getSchedulingNumber(),
                manualTechnologyDto.getManOrdId(),
                manualTechnologyDto.getOrderProcess());


        // 根据工序生产定额匹配时间
        List<ManufactureOrderProcess> manufactureOrderProcessesDate = datePeriodCalculate(
                manualTechnologyDto.getDate(),
                manufactureOrderProcessesPeriod);


        // 添加一条排产记录到manufacture_scheduling表格，返回主键Id
        Date endTime = manufactureOrderProcessesDate.get(manufactureOrderProcessesDate.size() - 1).getEndTime();
        ManufactureScheduling manufactureScheduling = new ManufactureScheduling()
                .setScheduled(manualTechnologyDto.getSchedulingNumber())
                .setStartTime(DateUtil.parse(manualTechnologyDto.getDate()))
                .setEndTime(endTime)
                .setManufactureOrderId(manualTechnologyDto.getManOrdId())
                .setGoState(0); // 0 表示待下达
        manufactureSchedulingService.save(manufactureScheduling);


        // 将排表Id插入到manufactureOrderProcessesDate中, 开始批量插入manufactureOrderProcesses表格
        manufactureOrderProcessesDate.forEach(i -> i.setManufactureSchedulingId(manufactureScheduling.getId()));
        manufactureOrderProcessService.batchInsert(manufactureOrderProcessesDate);


        // 更新订单的已排产数量
        manufactureOrderMapper.updateManufacture(manualTechnologyDto.getManOrdId(), manualTechnologyDto.getSchedulingNumber());
    }

    // 根据排产数量计算工艺周期
    private List<ManufactureOrderProcess> matchingCycle(Integer schedulingNumber, Integer manOrdId, List<ManualTechnologyDto1> manualTechnologyDtoList){
        // 查询编制工艺，用于匹配每个订单的工序周期
        LambdaQueryWrapper<ManualTechnology> queryWrapper = Wrappers.<ManualTechnology>lambdaQuery()
                .eq(ManualTechnology::getManufactureOrderId, manOrdId);
        List<ManualTechnology> technologies = manualTechnologyMapper.selectList(queryWrapper);

        //匹配每个订单的工序周期
        List<ManufactureOrderProcess> manufactureOrderProcessList = manualTechnologyDtoList.stream().map(manualTechnologyDto1 -> {
            ManufactureOrderProcess manufactureOrderProcess = new ManufactureOrderProcess();
            BeanUtils.copyProperties(manualTechnologyDto1, manufactureOrderProcess);
            technologies.forEach(i -> {
                if (Objects.equals(manufactureOrderProcess.getManualTechnologyId(), i.getId())){
                    manufactureOrderProcess.setPeriod((int) Math.ceil((double)schedulingNumber/i.getProductionQuota()));
                }
            });
            return manufactureOrderProcess;
        }).collect(Collectors.toList());
        return manufactureOrderProcessList;
    }

    // 根据工序生产定额匹配时间
    private List<ManufactureOrderProcess> datePeriodCalculate(String date, List<ManufactureOrderProcess> manualTechnologies) throws ParseException {
        // 计算工序的开始日期以及结束日期
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = dateFormat.parse(date);
        //将起始日期赋值给Calendar对象
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parse);
        //第一个工序
        ManufactureOrderProcess manualTechnology = manualTechnologies.get(0);
        calendar.add(Calendar.DATE, manualTechnology.getPeriod());

        manualTechnology.setStartTime(parse).setEndTime(calendar.getTime());
        //循环赋值时间
        for (int i = 0; i < manualTechnologies.size()-1 ; i++) {
            Calendar calendar1 = Calendar.getInstance();
            calendar1.setTime(manualTechnologies.get(i).getEndTime());
            ManufactureOrderProcess technology = manualTechnologies.get(i + 1);
            calendar1.add(Calendar.DATE,1);
            technology.setStartTime(calendar1.getTime());
            calendar1.add(Calendar.DATE,technology.getPeriod());
            technology.setEndTime(calendar1.getTime());
        }
        return manualTechnologies;
    }
}