package org.jeecg.modules.tms.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.flowable.engine.TaskService;
import org.flowable.task.api.Task;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.flowable.service.IFlowTaskService;
import org.jeecg.modules.tms.entity.*;
import org.jeecg.modules.tms.entity.dto.InboundOrderFlowDto;
import org.jeecg.modules.tms.entity.vo.InboundDetailVo;
import org.jeecg.modules.tms.mapper.InboundOrderMapper;
import org.jeecg.modules.tms.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;

/**
 * @Description: 入库申请单
 * @Author: jeecg-boot
 * @Date:   2025-05-19
 * @Version: V1.0
 */
@Service("IInboundOrderService")
public class InboundOrderServiceImpl extends ServiceImpl<InboundOrderMapper, InboundOrder> implements IInboundOrderService, FlowCallBackServiceI {

    @Autowired
    private FlowCommonService flowCommonService;
    @Autowired
    private IFlowDefinitionService flowDefinitionService;

    @Autowired
    private IFlowTaskService flowTaskService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IFlowMyBusinessService flowMyBusinessService;

    @Autowired
    private IBaseToolsService baseToolsService;

    @Autowired
    private IInStoreDetailService inStoreDetailService;

    @Autowired
    private IToolLedgerService toolLedgerService;

    @Autowired
    private IToolLedgerDetailService toolLedgerDetailService;

    @Autowired
    private IInboundDetailService inboundDetailService;
    @Override
    public boolean submit(String id) {
        InboundOrder inboundOrder = this.getById(id);
        //借用和刃磨入库时校验库存
        List<InboundDetail> inboundDetailList = inboundDetailService.lambdaQuery().eq(InboundDetail::getInStorehouseId,id).list();
        if("2".equals(inboundOrder.getInStorehouseType())){
            for(InboundDetail inboundDetail : inboundDetailList){
                if(StringUtils.isNotBlank(inboundDetail.getToolId())){
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolId,inboundDetail.getToolId()).one();
                    if(toolLedgerDetail.getQuantity().compareTo(inboundDetail.getInStorageQuantity()) == 0){
                        throw new JeecgBootException("编码为【" + toolLedgerDetail.getToolId() + "】的工具未借出，不需要归还入库！");
                    }
                }else {
                    ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId,inboundDetail.getToolCode()).one();
                    if(toolLedger.getLendCount().compareTo(inboundDetail.getInStorageQuantity()) < 0){
                        throw new JeecgBootException("编码为【" + toolLedger.getToolId() + "】的工具未借出，不需要归还入库！");
                    }
                }
            }
        }else if("5".equals(inboundOrder.getInStorehouseType())){
            for(InboundDetail inboundDetail : inboundDetailList){
                if(StringUtils.isNotBlank(inboundDetail.getToolId())){
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolId,inboundDetail.getToolId()).one();
                    if(toolLedgerDetail.getQuantity().compareTo(inboundDetail.getInStorageQuantity()) == 0){
                        throw new JeecgBootException("编码为【" + toolLedgerDetail.getToolId() + "】的工具未刃磨，不需要刃磨入库！");
                    }
                }else {
                    ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId,inboundDetail.getToolCode()).one();
                    if(toolLedger.getSharpeningCount().compareTo(inboundDetail.getInStorageQuantity()) < 0){
                        throw new JeecgBootException("编码为【" + toolLedger.getToolId() + "】的工具未刃磨，不需要刃磨入库！");
                    }
                }
            }
        }
        //发起审批流程
        this.triggerProcess(inboundOrder);
        //更新入库单审批状态为已提交
        inboundOrder.setOrderStatus("2");
        this.updateById(inboundOrder);
        return true;
    }

    /**
     * 触发流程
     *
     * @param inboundOrder
     * @return
     */
    public boolean triggerProcess(InboundOrder inboundOrder) {

        flowCommonService.initActBusiness("入库申请单号：" + inboundOrder.getInboundNum()+"发起审批流程",
                inboundOrder.getId(), "IInboundOrderService", "tool_in_storage", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", inboundOrder.getId());
        variables.put("organization", "新增入库申请单默认启动流程");
        variables.put("comment", "新增入库申请单默认启动流程");
        variables.put("proofreading", true);
        List<String> usernames = new ArrayList<>();
        usernames.add(inboundOrder.getReviewer());
        variables.put("NextAssignee", usernames);
        Result result = flowDefinitionService.startProcessInstanceByKey("tool_in_storage", variables);
        return result.isSuccess();
    }

    @Override
    public void afterFlowHandle(FlowMyBusiness business) {
        business.getTaskNameId();//接下来审批的节点
        business.getValues();//前端传进来的参数
        business.getActStatus();
    }

    @Override
    public Object getBusinessDataById(String dataId) {
        return this.getById(dataId);
    }

    @Override
    public Map<String, Object> flowValuesOfTask(String taskNameId, Map<String, Object> values) {
        return null;
    }

    @Override
    public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
        //业务是否干预流程，业务干预，流程干预，指定人员进行处理
        //获取下一步处理人
        Object object = values.get("NextAssignee");
        return (List<String>) object;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void approvalProcess(InboundOrderFlowDto inboundOrderFlowDto) {
        if (StrUtil.isBlank(inboundOrderFlowDto.getTaskId()) || StrUtil.isBlank(inboundOrderFlowDto.getDataId())) {
            throw new JeecgBootException("非法参数！");
        }

        // 获取当前登录用户
        LoginUser user = getCurrentUser();
        if (user == null || StrUtil.isBlank(user.getId())) {
            throw new JeecgBootException("账号不存在");
        }

        //获取入库申请单信息
        InboundOrder inboundOrder = getById(inboundOrderFlowDto.getDataId());
        if (inboundOrder == null) {
            throw new JeecgBootException("未找到对应的出库申请单！");
        }

        //获取流程业务记录
        FlowMyBusiness flowMyBusiness = getFlowMyBusiness(inboundOrderFlowDto.getInstanceId());
        if (flowMyBusiness == null) {
            throw new JeecgBootException("流程记录不存在");
        }

        // 检查用户是否有权限操作任务
        if (!isUserAuthorized(flowMyBusiness, user)) {
            throw new JeecgBootException("用户无权操作此任务");
        }

        // 认领任务
        if (!claimTask(flowMyBusiness.getTaskId(), user)) {
            throw new JeecgBootException("任务不存在、已完成或已被他人认领");
        }

        //设置流程变量
        setupProcessVariables(inboundOrderFlowDto, inboundOrder, user);

        //完成流程任务
        Result result = flowTaskService.complete(inboundOrderFlowDto);

        //根据任务完成结果更新申请单状态
        if (result.isSuccess()) {
            if ("3".equals(inboundOrderFlowDto.getStatus())) {
                inboundOrder.setOrderStatus("3");
            }else if("4".equals(inboundOrderFlowDto.getStatus())){
                inboundOrder.setOrderStatus("1");
            }
            inboundOrder.setReviewer(user.getUsername());
            inboundOrder.setApprovalDate(new Date());
            inboundOrder.setApprovalOpinion(inboundOrderFlowDto.getApprovalOpinion());
            updateById(inboundOrder);
        }
    }

    @Override
    public void addInStorage(JSONObject jSONObject) {
        String inStorehouseType = jSONObject.getString("inStorehouseType");
        String classifyId = jSONObject.getString("classifyId");
        Date inboundTime = jSONObject.getDate("inboundTime");
        //获取入库明细
        JSONArray jsonArray = jSONObject.getJSONArray("detailData");
        List<InboundDetailVo> inStoreDetailList =jsonArray.toJavaList(InboundDetailVo.class);
        //新货入库
        if("1".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList){
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //操作库存,查询总库存是否存在该类刀具
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId,inboundDetailVo.getToolCodeId()).one();
                if(toolLedger == null){
                    ToolLedger newToolLedger = new ToolLedger();
                    newToolLedger.setToolId(inboundDetailVo.getToolCodeId());
                    newToolLedger.setAvailableCount(inboundDetailVo.getInStorageQuantity());
                    newToolLedger.setTotalCount(inboundDetailVo.getInStorageQuantity());
                    newToolLedger.setLendCount(BigDecimal.ZERO);
                    newToolLedger.setDetectionCount(BigDecimal.ZERO);
                    newToolLedger.setLossCount(BigDecimal.ZERO);
                    newToolLedger.setRepairCount(BigDecimal.ZERO);
                    newToolLedger.setSharpeningCount(BigDecimal.ZERO);
                    newToolLedger.setClassifyId(classifyId);
                    toolLedgerService.save(newToolLedger);
                }else {
                    toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedger.setTotalCount(toolLedger.getTotalCount().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerService.updateById(toolLedger);
                }
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //循环入库数量，为实物赋码
                    for(int i=0;i<inboundDetailVo.getInStorageQuantity().intValue();i++){
                        BaseTools newBaseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                        //查询当前编码
                        String currentCode = newBaseTools.getCurrentCode();
                        //将字符串转换为整数
                        int num = Integer.parseInt(currentCode);
                        //加1操作
                        num++;
                        //转换回字符串并保留前导零
                        String result = String.format("%0" + currentCode.length() + "d", num);
                        //保存入库流水
                        InStoreDetail inStoreDetail = new InStoreDetail();
                        inStoreDetail.setInboundTime(inboundTime);
                        inStoreDetail.setOperateType("2");
                        inStoreDetail.setInNumber(BigDecimal.ONE);
                        inStoreDetail.setInStorehouseType("1");
                        inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        inStoreDetail.setToolId(inboundDetailVo.getToolCode()+"-"+result);
                        inStoreDetailService.save(inStoreDetail);
                        //增加库存明细
                        ToolLedgerDetail toolLedgerDetail = new ToolLedgerDetail();
                        toolLedgerDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        toolLedgerDetail.setToolId(inboundDetailVo.getToolCode()+"-"+result);
                        toolLedgerDetail.setQuantity(BigDecimal.ONE);
                        toolLedgerDetail.setStatus("1");
                        toolLedgerDetailService.save(toolLedgerDetail);
                        //更新当前编码
                        newBaseTools.setCurrentCode(result);
                        baseToolsService.updateById(newBaseTools);
                    }
                    //不管到把
                }else {
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(inboundTime);
                    inStoreDetail.setOperateType("2");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("1");
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                    //查询库存明细中是否存在该工具
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    if(toolLedgerDetail == null){
                        ToolLedgerDetail newToolLedgerDetail = new ToolLedgerDetail();
                        newToolLedgerDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        newToolLedgerDetail.setQuantity(inboundDetailVo.getInStorageQuantity());
                        newToolLedgerDetail.setStatus("1");
                        toolLedgerDetailService.save(newToolLedgerDetail);
                    }else {
                        toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                        toolLedgerDetailService.updateById(toolLedgerDetail);
                    }
                }
            }
            //归还入库
        }else if("2".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList) {
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //增加可用库存，减少借出库存
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId, inboundDetailVo.getToolCodeId()).one();
                toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                toolLedger.setLendCount(toolLedger.getLendCount().subtract(inboundDetailVo.getInStorageQuantity()));
                toolLedgerService.updateById(toolLedger);
                //查询是否管到把，管到把的用toolId，不管到把的用toolCodeId
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery()
                            .eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId())
                            .eq(ToolLedgerDetail::getToolId,inboundDetailVo.getOnlyCode()).one();
                    toolLedgerDetail.setQuantity(BigDecimal.ONE);
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(inboundTime);
                    inStoreDetail.setOperateType("2");
                    inStoreDetail.setInNumber(BigDecimal.ONE);
                    inStoreDetail.setInStorehouseType("2");
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetail.setToolId(inboundDetailVo.getOnlyCode());
                    inStoreDetailService.save(inStoreDetail);
                    //不管到把
                }else {
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(inboundTime);
                    inStoreDetail.setOperateType("2");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("2");
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                }

            }
        }else if("5".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList) {
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //增加总库存及可用库存，减少刃磨库存
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId, inboundDetailVo.getToolCodeId()).one();
                toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                toolLedger.setSharpeningCount(toolLedger.getSharpeningCount().subtract(inboundDetailVo.getInStorageQuantity()));
                toolLedgerService.updateById(toolLedger);
                //查询是否管到把，管到把的用toolId，不管到把的用toolCodeId
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery()
                            .eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId())
                            .eq(ToolLedgerDetail::getToolId,inboundDetailVo.getOnlyCode()).one();
                    toolLedgerDetail.setQuantity(BigDecimal.ONE);
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(inboundTime);
                    inStoreDetail.setOperateType("2");
                    inStoreDetail.setInNumber(BigDecimal.ONE);
                    inStoreDetail.setInStorehouseType("5");
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetail.setToolId(inboundDetailVo.getOnlyCode());
                    inStoreDetailService.save(inStoreDetail);
                    //不管到把
                }else {
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(inboundTime);
                    inStoreDetail.setOperateType("2");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("5");
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                }

            }
        }
    }

    @Override
    public void addApplyInStorage(JSONObject jSONObject) {
        String inStorehouseType = jSONObject.getString("inStorehouseType");
        //入库申请单id
        String orderId = jSONObject.getString("orderId");
        //获取入库明细
        JSONArray jsonArray = jSONObject.getJSONArray("detailData");
        List<InboundDetailVo> inStoreDetailList =jsonArray.toJavaList(InboundDetailVo.class);
        //新货入库
        if("1".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList){
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //操作库存,查询总库存是否存在该类刀具
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId,inboundDetailVo.getToolCodeId()).one();
                if(toolLedger == null){
                    ToolLedger newToolLedger = new ToolLedger();
                    newToolLedger.setToolId(inboundDetailVo.getToolCodeId());
                    newToolLedger.setAvailableCount(inboundDetailVo.getInStorageQuantity());
                    newToolLedger.setTotalCount(inboundDetailVo.getInStorageQuantity());
                    newToolLedger.setLendCount(BigDecimal.ZERO);
                    newToolLedger.setDetectionCount(BigDecimal.ZERO);
                    newToolLedger.setLossCount(BigDecimal.ZERO);
                    newToolLedger.setRepairCount(BigDecimal.ZERO);
                    newToolLedger.setSharpeningCount(BigDecimal.ZERO);
                    newToolLedger.setClassifyId(inboundDetailVo.getClassifyId());
                    toolLedgerService.save(newToolLedger);
                }else {
                    toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedger.setTotalCount(toolLedger.getTotalCount().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerService.updateById(toolLedger);
                }
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //循环入库数量，为实物赋码
                    for(int i=0;i<inboundDetailVo.getInStorageQuantity().intValue();i++){
                        BaseTools newBaseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                        //查询当前编码
                        String currentCode = newBaseTools.getCurrentCode();
                        //将字符串转换为整数
                        int num = Integer.parseInt(currentCode);
                        //加1操作
                        num++;
                        //转换回字符串并保留前导零
                        String result = String.format("%0" + currentCode.length() + "d", num);
                        //保存入库流水
                        InStoreDetail inStoreDetail = new InStoreDetail();
                        inStoreDetail.setInStorehouseId(orderId);
                        inStoreDetail.setInboundTime(new Date());
                        inStoreDetail.setOperateType("1");
                        inStoreDetail.setInNumber(BigDecimal.ONE);
                        inStoreDetail.setInStorehouseType("1");
                        inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        inStoreDetail.setToolId(inboundDetailVo.getToolCode()+"-"+result);
                        inStoreDetailService.save(inStoreDetail);
                        //增加库存明细
                        ToolLedgerDetail toolLedgerDetail = new ToolLedgerDetail();
                        toolLedgerDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        toolLedgerDetail.setToolId(inboundDetailVo.getToolCode()+"-"+result);
                        toolLedgerDetail.setQuantity(BigDecimal.ONE);
                        toolLedgerDetail.setStatus("1");
                        toolLedgerDetailService.save(toolLedgerDetail);
                        //更新当前编码
                        newBaseTools.setCurrentCode(result);
                        baseToolsService.updateById(newBaseTools);
                    }
                    //不管到把
                }else {
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(new Date());
                    inStoreDetail.setOperateType("1");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("1");
                    inStoreDetail.setInStorehouseId(orderId);
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                    //查询库存明细中是否存在该工具
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    if(toolLedgerDetail == null){
                        ToolLedgerDetail newToolLedgerDetail = new ToolLedgerDetail();
                        newToolLedgerDetail.setToolCode(inboundDetailVo.getToolCodeId());
                        newToolLedgerDetail.setQuantity(inboundDetailVo.getInStorageQuantity());
                        newToolLedgerDetail.setStatus("1");
                        toolLedgerDetailService.save(newToolLedgerDetail);
                    }else {
                        toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                        toolLedgerDetailService.updateById(toolLedgerDetail);
                    }
                }
                //更改明细入库状态及实际入库数量
                InboundDetail inboundDetail = inboundDetailService.getById(inboundDetailVo.getId());
                inboundDetail.setInStatus("3");
                inboundDetail.setInActualCount(inboundDetailVo.getInStorageQuantity());
                inboundDetailService.updateById(inboundDetail);
            }
            //归还入库
        }else if("2".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList) {
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //增加可用库存，减少借出库存
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId, inboundDetailVo.getToolCodeId()).one();
                toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                toolLedger.setLendCount(toolLedger.getLendCount().subtract(inboundDetailVo.getInStorageQuantity()));
                toolLedgerService.updateById(toolLedger);
                //查询是否管到把，管到把的用toolId，不管到把的用toolCodeId
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery()
                            .eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId())
                            .eq(ToolLedgerDetail::getToolId,inboundDetailVo.getOnlyCode()).one();
                    toolLedgerDetail.setQuantity(BigDecimal.ONE);
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(new Date());
                    inStoreDetail.setOperateType("1");
                    inStoreDetail.setInNumber(BigDecimal.ONE);
                    inStoreDetail.setInStorehouseType("2");
                    inStoreDetail.setInStorehouseId(orderId);
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetail.setToolId(inboundDetailVo.getOnlyCode());
                    inStoreDetailService.save(inStoreDetail);
                    //不管到把
                }else {
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(new Date());
                    inStoreDetail.setOperateType("1");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("2");
                    inStoreDetail.setInStorehouseId(orderId);
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                }
                //更改明细入库状态及实际入库数量
                InboundDetail inboundDetail = inboundDetailService.getById(inboundDetailVo.getId());
                inboundDetail.setInStatus("3");
                inboundDetail.setInActualCount(inboundDetailVo.getInStorageQuantity());
                inboundDetailService.updateById(inboundDetail);
            }
        }else if("5".equals(inStorehouseType)){
            //循环新增明细
            for(InboundDetailVo inboundDetailVo : inStoreDetailList) {
                //查询是否管到把，管到把的查询当前编码
                BaseTools baseTools = baseToolsService.getById(inboundDetailVo.getToolCodeId());
                //增加总库存及可用库存，减少刃磨库存
                ToolLedger toolLedger = toolLedgerService.lambdaQuery().eq(ToolLedger::getToolId, inboundDetailVo.getToolCodeId()).one();
                toolLedger.setAvailableCount(toolLedger.getAvailableCount().add(inboundDetailVo.getInStorageQuantity()));
                toolLedger.setSharpeningCount(toolLedger.getSharpeningCount().subtract(inboundDetailVo.getInStorageQuantity()));
                toolLedgerService.updateById(toolLedger);
                //查询是否管到把，管到把的用toolId，不管到把的用toolCodeId
                //管到把
                if("1".equals(baseTools.getAccuracyClass())){
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery()
                            .eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId())
                            .eq(ToolLedgerDetail::getToolId,inboundDetailVo.getOnlyCode()).one();
                    toolLedgerDetail.setQuantity(BigDecimal.ONE);
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(new Date());
                    inStoreDetail.setOperateType("1");
                    inStoreDetail.setInNumber(BigDecimal.ONE);
                    inStoreDetail.setInStorehouseType("5");
                    inStoreDetail.setInStorehouseId(orderId);
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetail.setToolId(inboundDetailVo.getOnlyCode());
                    inStoreDetailService.save(inStoreDetail);
                    //不管到把
                }else {
                    //增加库存明细可用库存，修改状态
                    ToolLedgerDetail toolLedgerDetail = toolLedgerDetailService.lambdaQuery().eq(ToolLedgerDetail::getToolCode,inboundDetailVo.getToolCodeId()).one();
                    toolLedgerDetail.setQuantity(toolLedgerDetail.getQuantity().add(inboundDetailVo.getInStorageQuantity()));
                    toolLedgerDetail.setStatus("1");
                    toolLedgerDetailService.updateById(toolLedgerDetail);
                    //保存入库流水
                    InStoreDetail inStoreDetail = new InStoreDetail();
                    inStoreDetail.setInboundTime(new Date());
                    inStoreDetail.setOperateType("1");
                    inStoreDetail.setInNumber(inboundDetailVo.getInStorageQuantity());
                    inStoreDetail.setInStorehouseType("5");
                    inStoreDetail.setInStorehouseId(orderId);
                    inStoreDetail.setToolCode(inboundDetailVo.getToolCodeId());
                    inStoreDetailService.save(inStoreDetail);
                }
                //更改明细入库状态及实际入库数量
                InboundDetail inboundDetail = inboundDetailService.getById(inboundDetailVo.getId());
                inboundDetail.setInStatus("3");
                inboundDetail.setInActualCount(inboundDetailVo.getInStorageQuantity());
                inboundDetailService.updateById(inboundDetail);
            }
        }
        //更改申请单入库状态
        InboundOrder inboundOrder = this.getById(orderId);
        List<InboundDetail> inboundDetailList = inboundDetailService.lambdaQuery().eq(InboundDetail::getInStorehouseId,orderId).list();
        boolean flag = inboundDetailList.stream().allMatch(inboundDetail -> "3".equals(inboundDetail.getInStatus()));
        if(flag){
            inboundOrder.setInStatus("3");
        }else {
            inboundOrder.setInStatus("2");
        }
        this.updateById(inboundOrder);
    }

    private LoginUser getCurrentUser() {
        // 获取当前认证的登录用户信息
        Subject currentUser = SecurityUtils.getSubject();
        if (currentUser != null && currentUser.isAuthenticated()) {
            Object principal = currentUser.getPrincipal();
            if (principal instanceof LoginUser) {
                return (LoginUser) principal;
            }
        }
        return null;
    }

    private FlowMyBusiness getFlowMyBusiness(String instanceId) {
        List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                new LambdaQueryWrapper<FlowMyBusiness>().eq(FlowMyBusiness::getProcessInstanceId, instanceId));
        return businessList.isEmpty() ? null : businessList.get(0);
    }

    private boolean isUserAuthorized(FlowMyBusiness flowMyBusiness, LoginUser user) {
        List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
        return todoUsers != null && todoUsers.contains(user.getUsername());
    }

    private boolean claimTask(String taskId, LoginUser user) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            return false;
        }
        if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
            return false;
        }
        taskService.claim(taskId, user.getUsername());
        return true;
    }

    private void setupProcessVariables(InboundOrderFlowDto inboundOrderFlowDto, InboundOrder inboundOrder, LoginUser user) {
        if ("2".equals(inboundOrder.getOrderStatus()) && user.getUsername().equals(inboundOrder.getReviewer())) {
            Map<String, Object> values = new HashMap<>();
            values.put("dataId", inboundOrder.getId());
            values.put("organization", inboundOrderFlowDto.getApprovalOpinion());
            values.put("comment", inboundOrderFlowDto.getApprovalOpinion());
            values.put("status", inboundOrderFlowDto.getStatus());
            values.put("NextAssignee", Collections.singletonList(inboundOrder.getReviewer()));
            inboundOrderFlowDto.setValues(values);
        }
    }
}