package com.mes.damage.service.impl;

import cn.hutool.core.date.DateTime;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.mes.damage.entity.Damage;
import com.mes.damage.mapper.DamageMapper;
import com.mes.damage.service.DamageService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.pp.entity.BasicDataProduce;
import com.mes.pp.entity.ReportingWork;
import com.mes.work_assignment.entity.WorkAssignment;
import com.mes.work_assignment.mapper.WorkAssignmentMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wu
 * @since 2024-06-13
 */
@Service
public class DamageServiceImpl extends ServiceImpl<DamageMapper, Damage> implements DamageService {

    @Resource
    GlassInfoMapper glassInfoMapper;
    @Resource
    WorkAssignmentMapper workAssignmentMapper;

    /**
     * 查询报工信息
     */
    @Override
    public List<Damage> selectDamage(String startTime, String endTime, int type, int status, String workingProcedure){
        LambdaQueryWrapper<Damage> damageSelectWrapper =new LambdaQueryWrapper<>();
        damageSelectWrapper.between(Damage::getDamageTime,startTime,endTime);
        if (type!=0){
            damageSelectWrapper.eq(Damage::getType,type);
        }
        if (status!=0){
            damageSelectWrapper.eq(Damage::getStatus,status);
        }
        if(!"0".equals(workingProcedure)){
            damageSelectWrapper.eq(Damage::getWorkingProcedure,workingProcedure);
        }
        return baseMapper.selectList(damageSelectWrapper);
    }

    /**
     * 提交报工
     */
    @Override
    public void submitDamage(String startTime, String endTime, int type, int status, String workingProcedures){
        LambdaUpdateWrapper<Damage> damageUpdateWrapper=new LambdaUpdateWrapper<>();
        LambdaQueryWrapper<Damage> damageLambdaQueryWrapper=new LambdaQueryWrapper<>()
;       damageUpdateWrapper.between(Damage::getDamageTime,startTime,endTime);
        damageLambdaQueryWrapper.between(Damage::getDamageTime,startTime,endTime);
        if (type!=0){
            damageUpdateWrapper.eq(Damage::getType,type);
            damageLambdaQueryWrapper.eq(Damage::getType,type);
        }
        if (status!=0){
            damageUpdateWrapper.eq(Damage::getStatus,status);
            damageLambdaQueryWrapper.eq(Damage::getStatus,status);
        }
        if(!"0".equals(workingProcedures)){
            damageUpdateWrapper.eq(Damage::getWorkingProcedure,workingProcedures);
            damageLambdaQueryWrapper.eq(Damage::getWorkingProcedure,workingProcedures);
        }
//        Damage damage=new Damage();
//        damage.setStatus(2);
//        baseMapper.update(damage,damageUpdateWrapper);
        List<Damage> damageList = baseMapper.selectList(damageLambdaQueryWrapper);
        Map<String, Map<String, Map<String, Map<String, List<Damage>>>>> resultMap = damageList.stream()
                .collect(Collectors.groupingBy(
                        Damage::getProcessId,
                        Collectors.groupingBy(
                                Damage::getWorkingProcedure,
                                Collectors.groupingBy(
                                        Damage::getDeviceName,
                                        Collectors.groupingBy(Damage::getTeamsGroupsName)
                                )
                        )
                ));
        // 遍历 resultMap
        for (Map.Entry<String, Map<String, Map<String, Map<String, List<Damage>>>>> processEntry : resultMap.entrySet()) {
            String processId = processEntry.getKey();
            System.out.println("ProcessId: " + processId);

            // 获取第二层的 Map，按 workingProcedure 分组的结果
            Map<String, Map<String, Map<String, List<Damage>>>> workingProcedureMap = processEntry.getValue();

            // 遍历 workingProcedureMap
            for (Map.Entry<String, Map<String, Map<String, List<Damage>>>> workingProcedureEntry : workingProcedureMap.entrySet()) {
                String workingProcedure = workingProcedureEntry.getKey();
                System.out.println("  WorkingProcedure: " + workingProcedure);

                // 获取第三层的 Map，按 deviceName 分组的结果
                Map<String, Map<String, List<Damage>>> deviceNameMap = workingProcedureEntry.getValue();

                // 遍历 deviceNameMap
                for (Map.Entry<String, Map<String, List<Damage>>> deviceNameEntry : deviceNameMap.entrySet()) {
                    String deviceName = deviceNameEntry.getKey();
                    System.out.println("    DeviceName: " + deviceName);

                    // 获取第四层的 Map，按 teamsGroupsName 分组的结果
                    Map<String, List<Damage>> teamsGroupsNameMap = deviceNameEntry.getValue();

                    // 遍历 teamsGroupsNameMap
                    for (Map.Entry<String, List<Damage>> teamsGroupsNameEntry : teamsGroupsNameMap.entrySet()) {
                        String teamsGroupsName = teamsGroupsNameEntry.getKey();
                        System.out.println("      TeamsGroupsName: " + teamsGroupsName);

                        // 获取 Damage 列表
                        List<Damage> damageListForTeamsGroupsName = teamsGroupsNameEntry.getValue();

                        // 使用 stream 对 damageListForTeamsGroupsName 进行再次分组
                        Map<Integer, Map<Integer, Map<String, List<Damage>>>> groupedByOrderTechBreakage = damageListForTeamsGroupsName.stream()
                                .collect(Collectors.groupingBy(
                                        Damage::getOrderNumber,
                                        Collectors.groupingBy(
                                                Damage::getTechnologyNumber,
                                                Collectors.groupingBy(
                                                        Damage::getBreakageType,
                                                        Collectors.toList()
                                                )
                                        )
                                ));

                        // 遍历 groupedByOrderTechBreakage
                        for (Map.Entry<Integer, Map<Integer, Map<String, List<Damage>>>> orderEntry : groupedByOrderTechBreakage.entrySet()) {
                            Integer orderNumber = orderEntry.getKey();
                            System.out.println("        OrderNumber: " + orderNumber);

                            // 获取第二层的 Map，按 technologyNumber 分组的结果
                            Map<Integer, Map<String, List<Damage>>> technologyNumberMap = orderEntry.getValue();

                            // 遍历 technologyNumberMap
                            for (Map.Entry<Integer, Map<String, List<Damage>>> technologyEntry : technologyNumberMap.entrySet()) {
                                Integer technologyNumber = technologyEntry.getKey();
                                System.out.println("          TechnologyNumber: " + technologyNumber);

                                // 获取第三层的 Map，按 breakageType 分组的结果
                                Map<String, List<Damage>> breakageTypeMap = technologyEntry.getValue();

                                // 遍历 breakageTypeMap
                                for (Map.Entry<String, List<Damage>> breakageTypeEntry : breakageTypeMap.entrySet()) {
                                    String breakageType = breakageTypeEntry.getKey();
                                    System.out.println("            BreakageType: " + breakageType);

                                    ReportingWork reportingWork=new ReportingWork();
                                    reportingWork.setProcessId(processId);
                                    reportingWork.setThisProcess(workingProcedure);
                                    reportingWork.setDeviceName(deviceName);
                                    reportingWork.setTeamsGroupsName(teamsGroupsName);
                                    // 获取 Damage 列表
                                    List<Damage> damageListForBreakageType = breakageTypeEntry.getValue();
                                    int completedQuantity=0;
                                    int breakageQuantity=0;
                                    // 遍历 Damage 列表
                                    for (Damage damage : damageListForBreakageType) {
                                        // 打印或处理每个 Damage 对象
                                        System.out.println("              Damage: " + damage.toString());
                                        if(damage.getType()==1){
                                            completedQuantity+=1;
                                        }else if(damage.getType()==2){
                                            breakageQuantity+=1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }




    }

    /**
     * 添加报工信息
     */
    @Override
    public void insertDamage(Damage damage){
        LambdaQueryWrapper<GlassInfo> glassInfoSelectWrapper=new LambdaQueryWrapper<>();
        glassInfoSelectWrapper.eq(GlassInfo::getGlassId,damage.getGlassId());
        GlassInfo glassInfo=glassInfoMapper.selectOne(glassInfoSelectWrapper);
        BeanUtils.copyProperties(glassInfo, damage);

        LambdaQueryWrapper<WorkAssignment> workAssignmentSelectWrapper=new LambdaQueryWrapper<>();
        workAssignmentSelectWrapper
                .eq(WorkAssignment::getLine,damage.getLine())
                .eq(WorkAssignment::getWorkProcesses,damage.getWorkingProcedure());
        WorkAssignment workAssignment=workAssignmentMapper.selectOne(workAssignmentSelectWrapper);

        damage.setTeamsGroupsName(workAssignment.getTeamsGroupsName());
        damage.setDeviceName(workAssignment.getDeviceName());
        damage.setProcessId(glassInfo.getFlowCardId());
        damage.setOrderNumber(glassInfo.getGlassType());
        damage.setTechnologyNumber(glassInfo.getLayer());
        damage.setDamageTime(Timestamp.valueOf(LocalDateTime.now()));
        damage.setType(2);
        baseMapper.insert(damage);
    }
}