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

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.flowable.common.engine.api.FlowableException;
import org.flowable.engine.TaskService;
import org.flowable.identitylink.api.IdentityLink;
import org.flowable.task.api.Task;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.dnc.constant.DncPassLogPassType;
import org.jeecg.modules.dnc.constant.DocAttributionTypeEnum;
import org.jeecg.modules.dnc.dto.TransferPackage;
import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.response.ActivitiCode;
import org.jeecg.modules.dnc.response.CommonCode;
import org.jeecg.modules.dnc.response.DocumentCode;
import org.jeecg.modules.dnc.response.UcenterCode;
import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.service.impl.FileFerryService;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.dnc.utils.date.DateUtil;
import org.jeecg.modules.dnc.utils.file.FileUtilS;
import org.jeecg.modules.dncFlow.constant.GuideCardBatchEnum;
import org.jeecg.modules.dncFlow.entity.AssignEquipmentFileStream;
import org.jeecg.modules.dncFlow.entity.DispatchFile;
import org.jeecg.modules.dncFlow.mapper.AssignEquipmentFileStreamMapper;
import org.jeecg.modules.dncFlow.service.IAssignEquipmentFileStreamService;
import org.jeecg.modules.dncFlow.vo.AssignEquipmentFileStreamVo;
import org.jeecg.modules.dncFlow.vo.DispatchFileFlowTaskVo;
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.mdc.entity.MdcEquipment;
import org.jeecg.modules.mdc.service.IMdcEquipmentService;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.ISysUserRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.NoTransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.io.File;
import java.util.*;

/**
 * @Description: DNC-设备结构树指派产品结构树
 * @Author: jeecg-boot
 * @Date:   2025-06-17
 * @Version: V1.0
 */
@Service("IAssignEquipmentFileStreamService")
public class AssignEquipmentFileStreamServiceImpl extends ServiceImpl<AssignEquipmentFileStreamMapper, AssignEquipmentFileStream> implements IAssignEquipmentFileStreamService , FlowCallBackServiceI {

    @Autowired
    private IDocInfoService docInfoService;
    @Autowired
    private IDocFileService docFileService;
    @Autowired
    private IMdcEquipmentService mdcEquipmentService;
    @Autowired
    private IGuideCardBatchService iGuideCardBatchService;
    @Resource
    private FlowCommonService flowCommonService;
    @Resource
    private IFlowDefinitionService flowDefinitionService;
    @Autowired
    private IFlowTaskService flowTaskService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IFlowMyBusinessService flowMyBusinessService;
    @Autowired
    private IDocRelativeService docRelativeService;
    @Autowired
    private IDeviceTypeService deviceTypeService;
    @Autowired
    private PermissionService permissionService;
    /**
     * 流程启动,保存对应的数据
     * @param assignEquipmentFileStream
     * @return
     */
    @Override
    public Result<?> saveAssignEquipmentFileStream(AssignEquipmentFileStream assignEquipmentFileStream){
        //参数校验
        checkParam(assignEquipmentFileStream);
        //获取设备
        MdcEquipment equipment = mdcEquipmentService.getById(assignEquipmentFileStream.getEquipmentId());
        if(equipment==null){
            return Result.error("未发现该设备");
        }
        //获取设备文档信息
        DocInfo docInfo =docInfoService.getById(assignEquipmentFileStream.getEquipmentDocId());
        if(docInfo==null){
            return Result.error("未发现该设备对应文档");
        }
        //获取设备文件信息
        DocFile docFile =docFileService.getById(assignEquipmentFileStream.getEquipmentFileId());
        if(docFile==null){
            return Result.error("未发现该设备对应文件");
        }
        //获取产品文档信息
        DocRelative docRelative=docRelativeService.getById(assignEquipmentFileStream.getDocId());
        //获取对应设备类
        DeviceType deviceType = deviceTypeService.getById(docRelative.getAttributionId());
        if(deviceType!=null){
            assignEquipmentFileStream.setDeviceTypeId(deviceType.getId());
            assignEquipmentFileStream.setAttributionId(deviceType.getAttributionId());
            assignEquipmentFileStream.setAttributionType(deviceType.getAttributionType().toString());
            PermissionStreamNew permissionStreamNew=permissionService.getPermissionStreams(assignEquipmentFileStream);
            if(permissionStreamNew==null){
                return Result.error("用户无权操作此任务");
            }
        }
        DocInfo productDocInfo =docInfoService.getById(docRelative.getDocId());
        if(productDocInfo==null){
            return Result.error("未发现该产品结构树对应文档");
        }
        if (productDocInfo.getDocDispatchStatus()==5){
            return Result.error("已被定型的文档不能进行升版");
        }
        //是否又进行的升版
        AssignEquipmentFileStream productAssignEquipmentFileStream = this.getOne(
                new QueryWrapper<AssignEquipmentFileStream>().eq("doc_id", productDocInfo.getDocId())
                        .isNull("audit_type"));
        if(productAssignEquipmentFileStream!=null){
            return Result.error("该文档已经进行过升版");
        }
        //获取产品文档信息对应最新程序加工确认表
        List<GuideCardBatch> batches = iGuideCardBatchService.list(
                new QueryWrapper<GuideCardBatch>()
                        .eq("doc_id", productDocInfo.getDocId())
                        .eq("flow_status", GuideCardBatchEnum.COMPLETE.getCode())
                        .orderByDesc("SUBSTRING(serial_number, LEN(serial_number)-3, 4)"));
        if(CollectionUtils.isEmpty(batches)){
            return Result.error("该文档对应的程序加工确认表审批未通过，不能进行升版");
        }
        this.save(assignEquipmentFileStream);
        System.out.println("设备结构树指派产品结构树：" + assignEquipmentFileStream.getId());
        flowCommonService.initActBusiness("设备结构树指派产品结构树:"+docInfo.getDocName()+"->"+productDocInfo.getDocName(),
                assignEquipmentFileStream.getId(), "IAssignEquipmentFileStreamService", "nc_assign_equipment_file_stream", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", assignEquipmentFileStream.getId());
        variables.put("organization", assignEquipmentFileStream.getApplyReason());
        variables.put("comment", assignEquipmentFileStream.getApplyReason());
        variables.put("proofreading",true);
        Result result= flowDefinitionService.startProcessInstanceByKey("nc_assign_equipment_file_stream", variables);
        if (!result.isSuccess()) {
            super.removeById(assignEquipmentFileStream.getId());
        }
        return result;
    }

    /**
     * 流程节点审核
     * @param assignEquipmentFileStreamVo
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public Result<?> auditAssignEquipmentFileStream(AssignEquipmentFileStreamVo assignEquipmentFileStreamVo){
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        try {
            // 参数校验
            if (!ValidateUtil.validateString(assignEquipmentFileStreamVo.getTaskId()) || !ValidateUtil.validateString(assignEquipmentFileStreamVo.getDataId())) {
                return Result.error(CommonCode.INVALID_PARAM.toString());
            }
            String userId = user.getId();
            assignEquipmentFileStreamVo.setAssignee(user.getUsername());
            if (!ValidateUtil.validateString(userId)) {
                return Result.error(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST.toString());
            }

            // 数据查询
            AssignEquipmentFileStream assignEquipmentFileStream = this.getById(assignEquipmentFileStreamVo.getDataId());
            if (assignEquipmentFileStream == null) {
                return Result.error(CommonCode.INVALID_PARAM.toString());
            }
            //获取设备
            MdcEquipment equipment = mdcEquipmentService.getById(assignEquipmentFileStream.getEquipmentId());
            if(equipment==null){
                return Result.error("未发现该设备");
            }
            //获取设备文档信息
            DocInfo docInfo =docInfoService.getById(assignEquipmentFileStream.getEquipmentDocId());
            if(docInfo==null){
                return Result.error("未发现该设备对应文档");
            }
            //获取设备文件信息
            DocFile docFile =docFileService.getById(assignEquipmentFileStream.getEquipmentFileId());
            if(docFile==null){
                return Result.error("未发现该设备对应文件");
            }
            //获取产品文档信息
            DocRelative docRelative=docRelativeService.getById(assignEquipmentFileStream.getDocId());
            DocInfo productDocInfo =docInfoService.getById(docRelative.getDocId());
            if(productDocInfo==null){
                return Result.error("未发现该产品结构树对应文档");
            }
            //是否又进行的升版
            AssignEquipmentFileStream productAssignEquipmentFileStream = this.getOne(
                    new QueryWrapper<AssignEquipmentFileStream>().eq("doc_id", productDocInfo.getDocId())
                            .isNull("audit_type"));
            if(productAssignEquipmentFileStream!=null){
                return Result.error("该文档已经进行过升版");
            }
            //获取设备
            MdcEquipment mdcEquipment =mdcEquipmentService.getById(assignEquipmentFileStream.getEquipmentId());
            if (mdcEquipment==null){
                return Result.error("未发现该设备");
            }
            // 2. 查询流程业务记录（处理空结果）
            List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                    new QueryWrapper<FlowMyBusiness>()
                            .eq("process_instance_id", assignEquipmentFileStreamVo.getInstanceId())
            );
            if (businessList.isEmpty()) {
                return Result.error("流程记录不存在");
            }
            FlowMyBusiness flowMyBusiness = businessList.get(0);

            // 3. 校验用户是否为候选处理人
            List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
            if (todoUsers == null || !todoUsers.contains(user.getUsername())) {
                return Result.error("用户无权操作此任务");
            }

            // 4. 认领任务（处理已被认领的情况）
            String taskId = flowMyBusiness.getTaskId();
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            if (task == null) {
                return Result.error("任务不存在或已完成");
            }
            if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
                return Result.error("任务已被他人认领");
            }
            taskService.claim(taskId, user.getUsername());

            // 设置流程变量
            Map<String, Object> values = new HashMap<>();
            values.put("dataId", assignEquipmentFileStream.getId());
            values.put("assignee", userId);
            values.put("comment", assignEquipmentFileStreamVo.getComment());
            values.put("organization", assignEquipmentFileStreamVo.getComment());
            assignEquipmentFileStreamVo.setValues(values);
            assignEquipmentFileStream.setAuditType(assignEquipmentFileStreamVo.getAuditType());
            assignEquipmentFileStream.setAuditReason(assignEquipmentFileStream.getAuditReason());
            // 完成流程任务
            Result result = flowTaskService.complete(assignEquipmentFileStreamVo);
            if (result.isSuccess()) {
                this.updateById(assignEquipmentFileStream);
                if (assignEquipmentFileStreamVo.getAuditType().equals("1")) {
                    //1.产品结构树nc文件进行升版
                    DocFile productDocFile = new DocFile();
                    productDocFile.setDocId(productDocInfo.getDocId());
                    productDocFile.setFileName(docFile.getFileName());
                    productDocFile.setFileEncodeName(docFile.getFileEncodeName());
                    productDocFile.setFilePath(docFile.getFilePath());
                    productDocFile.setFileSize(docFile.getFileSize());
                    productDocFile.setFileSuffix(docFile.getFileSuffix());
                    docFileService.addDocFile(productDocFile);
                    productDocInfo.setPublishVersion(productDocFile.getDocVersion());
                    productDocInfo.setPublishFileId(productDocFile.getFileId());
                    docInfoService.updateById(productDocInfo);
                }
            } else {
                return result;
            }
            return Result.OK("操作成功");
        }  catch (Exception e) {
            try {
                TransactionStatus transactionStatus = TransactionAspectSupport.currentTransactionStatus();
                if (!transactionStatus.isCompleted()) {
                    transactionStatus.setRollbackOnly();
                }
            } catch (NoTransactionException ex) {
                // 忽略无事务的异常
            }
            log.error("审核失败", e);
            return Result.error("操作失败：" + e.getMessage());
        }
    }


    //传参验证
    public boolean checkParam(AssignEquipmentFileStream assignEquipmentFileStream) {
        if (assignEquipmentFileStream == null) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        if (!ValidateUtil.validateString(assignEquipmentFileStream.getEquipmentId()) || !ValidateUtil.validateString(assignEquipmentFileStream.getDocId())
                || !ValidateUtil.validateString(assignEquipmentFileStream.getEquipmentFileId()) || !ValidateUtil.validateString(assignEquipmentFileStream.getEquipmentDocId())) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if (!ValidateUtil.validateString(userId)) {
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        }
        return true;
    }

    @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) {
        //业务是否干预流程，业务干预，流程干预，指定人员进行处理
        return null;
    }
}