package com.ruoyi.system.controller;

import cn.dev33.satoken.annotation.SaCheckPermission;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.excel.ExcelResult;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.MaterialBom;
import com.ruoyi.system.domain.ProcessRoute;
import com.ruoyi.system.domain.bo.ProcessRouteBo;
import com.ruoyi.system.domain.dto.CombinedDTO;
import com.ruoyi.system.jdmain.rouplan.Model;
import com.ruoyi.system.domain.dto.ProcessRouteXuDTO;
import com.ruoyi.system.domain.vo.ProcessRouteVo;
import com.ruoyi.system.domain.vo.ProductionOrderVo;
import com.ruoyi.system.service.IProcessRouteService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.*;

/**
 * 工艺路线
 *
 * @author ruoyi
 * @date 2024-10-09
 */
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/route")
public class ProcessRouteController extends BaseController {

    private final IProcessRouteService iProcessRouteService;
    private static final Logger log = LoggerFactory.getLogger(ProcessRouteController.class);

    private Long generateUniqueParentId( Long originalId) {
        return originalId + 1000;
    }

    /**
     * 查询工艺路线列表
     */
    @SaCheckPermission("system:route:list")
    @GetMapping("/list")
    public TableDataInfo<ProcessRouteVo> list(ProcessRouteBo bo, PageQuery pageQuery) {
        try {
            // 查询工艺路线数据
            TableDataInfo<ProcessRouteVo> processRouteVoTableDataInfo = iProcessRouteService.queryPageList(bo, pageQuery);
            // 用于存储父子关系的Map，key为"物料编码_物料名称"，值为父级ProcessRouteVo
            Map<String, ProcessRouteVo> routeMap = new HashMap<>();
            // 存储顶级列表
            List<ProcessRouteVo> topLevelList = new ArrayList<>();
            // 获取查询返回的行数据
            List<ProcessRouteVo> rows = processRouteVoTableDataInfo.getRows();
            // 遍历所有工艺路线记录
            for (ProcessRouteVo processRouteVo : rows) {
                // 组合父级键值，物料编码 + 物料名称
                String parentCodeAndName = String.format("%s_%s", processRouteVo.getMaterialCode(), processRouteVo.getMaterialName());
                // 查找是否已存在父节点
                ProcessRouteVo parent = routeMap.get(parentCodeAndName);
                if (parent == null) {
                    // 如果父节点不存在，创建并初始化
                    parent = new ProcessRouteVo();
                    parent.setId(generateUniqueParentId(processRouteVo.getId()));
                    parent.setRouteDescription(processRouteVo.getRouteDescription());
                    //parent.setParentId((Long.valueOf(generateUniqueParentId(processRouteVo.getId()))));
                    parent.setMaterialCode(processRouteVo.getMaterialCode());
                    parent.setMaterialName(processRouteVo.getMaterialName());
                    parent.setMaterial(processRouteVo.getMaterial());
                    parent.setDiscWeight(processRouteVo.getDiscWeight());
                    /*parent.setRawMaterialCode(processRouteVo.getRawMaterialCode());
                    parent.setRawMaterialName(processRouteVo.getRawMaterialName());
                    parent.setDiscUsage(processRouteVo.getDiscUsage());
                    parent.setBomUnit(processRouteVo.getBomUnit());
                    parent.setBomMaterial(processRouteVo.getBomMaterial());
                    parent.setProcessNo(processRouteVo.getProcessNo());
                    parent.setWorkCenter(processRouteVo.getWorkCenter());
                    parent.setProcessName(processRouteVo.getProcessName());
                    parent.setProcessDescription(processRouteVo.getProcessDescription());
                    parent.setProcessControl(processRouteVo.getProcessControl());
                    parent.setActivityDuration(processRouteVo.getActivityDuration());
                    parent.setActivityUnit(processRouteVo.getActivityUnit());
                    parent.setUnitQuantity(processRouteVo.getUnitQuantity());
                    parent.setBatchQuantity(processRouteVo.getBatchQuantity());
                    parent.setFirstBatchQuantity(processRouteVo.getFirstBatchQuantity());
                    parent.setPlanStartTime(processRouteVo.getPlanStartTime());
                    parent.setPlanEndTime(processRouteVo.getPlanEndTime());
                    parent.setXuStartTime(processRouteVo.getXuStartTime());
                    parent.setXuEndTime(processRouteVo.getXuEndTime());*/
                    // 初始化子节点列表
                    parent.setChildren(new ArrayList<>());
                    // 将父节点放入Map中
                    routeMap.put(parentCodeAndName, parent);
                    // 将父节点加入顶级列表
                    topLevelList.add(parent);
                }
                // 创建子节点，并将其添加到父节点的子集
                ProcessRouteVo child = createChildVo(processRouteVo, parent.getId());
                parent.getChildren().add(child);
            }

            // 设置返回的rows为顶级节点列表
            processRouteVoTableDataInfo.setRows(topLevelList);

            // 返回构建后的数据
            return processRouteVoTableDataInfo;
        } catch (Exception e) {
            e.printStackTrace();
            return new TableDataInfo<>();
        }
    }

    /**
     * 创建子节点的辅助方法
     *
     * @param processRouteVo 原始数据
     * @return ProcessRouteVo 子节点
     */
    private ProcessRouteVo createChildVo(ProcessRouteVo processRouteVo,Long parentId) {
        ProcessRouteVo child = new ProcessRouteVo();
        child.setId(processRouteVo.getId());
        child.setParentId(parentId);
       /* child.setMaterialCode(processRouteVo.getMaterialCode());
        child.setMaterialName(processRouteVo.getMaterialName());
        child.setMaterial(processRouteVo.getMaterial());
        child.setDiscWeight(processRouteVo.getDiscWeight());
        child.setRawMaterialCode(processRouteVo.getRawMaterialCode());
        child.setRawMaterialName(processRouteVo.getRawMaterialName());
        child.setDiscUsage(processRouteVo.getDiscUsage());
        child.setBomUnit(processRouteVo.getBomUnit());
        child.setBomMaterial(processRouteVo.getBomMaterial());*/
        child.setProcessNo(processRouteVo.getProcessNo());
        child.setWorkCenter(processRouteVo.getWorkCenter());
        child.setProcessName(processRouteVo.getProcessName());
        child.setProcessDescription(processRouteVo.getProcessDescription());
        child.setProcessControl(processRouteVo.getProcessControl());
        child.setActivityDuration(processRouteVo.getActivityDuration());
        child.setActivityUnit(processRouteVo.getActivityUnit());
        child.setUnitQuantity(processRouteVo.getUnitQuantity());
        child.setBatchQuantity(processRouteVo.getBatchQuantity());
        child.setFirstBatchQuantity(processRouteVo.getFirstBatchQuantity());
        child.setPlanStartTime(processRouteVo.getPlanStartTime());
        child.setPlanEndTime(processRouteVo.getPlanEndTime());
        child.setXuStartTime(processRouteVo.getXuStartTime());
        child.setXuEndTime(processRouteVo.getXuEndTime());
        return child;
    }

    /**
     * 导出工艺路线列表
     */
    @SaCheckPermission("system:route:export")
    @Log(title = "工艺路线", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(ProcessRouteBo bo, HttpServletResponse response) {
        List<ProcessRouteVo> list = iProcessRouteService.queryList(bo);
        ExcelUtil.exportExcel(list, "工艺路线", ProcessRouteVo.class, response);
    }

    /**
     * 获取工艺路线详细信息
     *
     * @param id 主键
     */
    @SaCheckPermission("system:route:query")
    @GetMapping("/{id}")
    public R<ProcessRouteVo> getInfo(@NotNull(message = "主键不能为空")
                                     @PathVariable Long id) {
        return R.ok(iProcessRouteService.queryById(id));
    }

    /**
     * 新增工艺路线
     */
    @SaCheckPermission("system:route:add")
    @Log(title = "工艺路线", businessType = BusinessType.INSERT)
    @RepeatSubmit()
    @PostMapping()
    public R<Void> add(@Validated(AddGroup.class) @RequestBody ProcessRouteBo bo) {
        return toAjax(iProcessRouteService.insertByBo(bo));
    }

    /**
     * 修改工艺路线
     */
    @SaCheckPermission("system:route:edit")
    @Log(title = "工艺路线", businessType = BusinessType.UPDATE)
    @RepeatSubmit()
    @PutMapping()
    public R<Void> edit(@Validated(EditGroup.class) @RequestBody ProcessRouteBo bo) {
        return toAjax(iProcessRouteService.updateByBo(bo));
    }

    /**
     * 删除工艺路线
     *
     * @param ids 主键串
     */
    @SaCheckPermission("system:route:remove")
    @Log(title = "工艺路线", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    public R<Void> remove(@NotEmpty(message = "主键不能为空")
                          @PathVariable Long[] ids) {
        return toAjax(iProcessRouteService.deleteWithValidByIds(Arrays.asList(ids), true));
    }


    @Log(title = "明细导入", businessType = BusinessType.IMPORT)
    @SaCheckPermission("system:route:import")
    @PostMapping(value = "/importData", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public R<Void> importData(@RequestParam("file") MultipartFile file) throws Exception {
        String originalFilename = file.getOriginalFilename();
        log.info("读取文件名: " + originalFilename);
        ExcelResult<ProcessRouteVo> result = ExcelUtil.importExcelSheet6(file.getInputStream(), ProcessRouteVo.class, true);
        ExcelResult<ProductionOrderVo> result1 = ExcelUtil.importExcelSheet1(file.getInputStream(), ProductionOrderVo.class, true);
        List<ProductionOrderVo> list = result1.getList();
        if (iProcessRouteService.saveData(result.getList(), list)) {
            return R.ok("上传物料成功");
        } else {
            return R.fail("导入失败");
        }
    }

    /**
     * 查询组焊件集合
     */
    @Log(title = "查询组焊件集合")
    @SaCheckPermission("system:route:pushGroupWeldments")
    @PostMapping("/pushGroupWeldments")
    public List<ProcessRoute> pushGroupWeldments(@RequestBody ProcessRoute processRoute) {
        return iProcessRouteService.pushGroupWeldments(processRoute);
    }

    /**
     * 查询需要单独生成BOm 的原材料集合
     */
    @Log(title = "查询需要单独生成BOM的原材料集合")
    @SaCheckPermission("system:route:getRawBom")
    @PostMapping("/getRawBom")
    public List<ProcessRoute> getRawBom(@RequestParam String rooteProdet) {
        return iProcessRouteService.getRawBom(rooteProdet);
    }

    /**
     * 查询工艺表中所有的需要做工艺的物料
     *
     * @return
     * RequestBody  List<ProcessRouteVo> routeVoList
     */
    public List<ProcessRoute> getProcessRouteList(@RequestParam String rooteProdet) {
        List<ProcessRoute> list = iProcessRouteService.pushRawMater(rooteProdet);
        return list;
    }


    @Log(title = "查询工艺工序集合")
    @SaCheckPermission("system:route:getProcessRoute")
    @PostMapping("/getProcessRoute")
    public List<ProcessRouteXuDTO> getProcessRoute(@RequestParam String rooteProdet) {
        return iProcessRouteService.getProcessRoute(rooteProdet);
    }

    @Log(title = "推送工艺工序")
    @SaCheckPermission("system:route:getProcessRoute")
    @PostMapping("/pushRouteBom")
    public List<ProcessRouteXuDTO> pushRouteBom(@RequestParam String rooteProdet) {
        return iProcessRouteService.pushRouteBom(rooteProdet);
    }

    /**
     * 查询项目列表
     */
    @Log(title = "获取所有的项目令号")
    @SaCheckPermission("system:route:getRawBom")
    @GetMapping("/getDistinctProjectCodes")
    public ResponseEntity<List<String>> getDistinctProjectCodes(String query) {
        return ResponseEntity.ok(iProcessRouteService.getDistinctProjectCodes(query));
    }
    @Log(title = "获取工序列表")
    @SaCheckPermission("system:route:getRawBom")
    @GetMapping("/getProcessInfoList")
    public ResponseEntity<List<String>> getProcessInfoList(String query) {
        return ResponseEntity.ok(iProcessRouteService.getProcessInfoList(query));
    }

    @Log(title = "根据生产令号获取生产编号==》获取计划编号")
    @SaCheckPermission("system:route:getRawBom")
    @PostMapping("/getSelecPlanRouteList")
    public List<CombinedDTO> getSelecPlanRouteList(@RequestParam String rooteProdet) {
        return iProcessRouteService.getSelecPlanRouteList(rooteProdet);
    }

    @Log(title = "生成这个项目的pdf")
    @SaCheckPermission("system:route:getRawBom")
    @PostMapping("/generatePDFs")
    public List<CombinedDTO> generatePDFs(@RequestParam String rooteProdet) {
        return iProcessRouteService.generatePDFs(rooteProdet);
    }

    @Log(title = "更新计划时间")
    @SaCheckPermission("system:route:updateProcessPlan")
    @PostMapping("/updateProcessPlan")
        public List<Model> updateProcessPlan(@RequestParam String rooteProdet) {
        return iProcessRouteService.updateProcessPlan(rooteProdet);
    }
    /**
     * 保存工艺路线
     */
    @SaCheckPermission("system:route:add")
    @Log(title = "保存工艺路线", businessType = BusinessType.INSERT)
    @RepeatSubmit()
    @PostMapping("/addRoute")
    public R<Void> addRoute( @RequestBody List<ProcessRoute> list) {
        return toAjax(iProcessRouteService.addRoute(list));
    }

    @SaCheckPermission("system:route:add")
    @Log(title = "删除工艺路线", businessType = BusinessType.INSERT)
    @RepeatSubmit()
    @PostMapping("/deleteRoute")
    public List<ProcessRoute> deleteRoute( @RequestBody ProcessRoute processRoute) {
        return iProcessRouteService.deleteRoute(processRoute);
    }

    @Log(title = "获取材料bom列表")
    @SaCheckPermission("system:route:getRawBom")
    @PostMapping("/getProcessMaterialList")
    public ResponseEntity<List<MaterialBom>> getProcessMaterialList(@RequestBody ProcessRoute processRoute) {
        return ResponseEntity.ok(iProcessRouteService.getProcessMaterialList(processRoute));
    }

}