package com.lxzn.nc.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxzn.auth.JwtUtil;
import com.lxzn.base.service.IDncPassLogService;
import com.lxzn.base.service.ISingleDictionaryService;
import com.lxzn.framework.domain.activiti.response.ActivitiCode;
import com.lxzn.framework.domain.base.DncPassLog;
import com.lxzn.framework.domain.base.SingleDictionary;
import com.lxzn.framework.domain.base.ext.NcTxtFilePathInfo;
import com.lxzn.framework.domain.filesystem.response.FileUploadResult;
import com.lxzn.framework.domain.nc.*;
import com.lxzn.framework.domain.nc.request.DocInfoQueryRequest;
import com.lxzn.framework.domain.nc.request.DocInfoUploadRequest;
import com.lxzn.framework.domain.nc.response.DocumentCode;
import com.lxzn.framework.domain.ucenter.response.UcenterCode;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.QueryListResponseResult;
import com.lxzn.framework.model.response.QueryPageResponseResult;
import com.lxzn.framework.model.response.ResponseResult;
import com.lxzn.framework.utils.BeanMapper;
import com.lxzn.framework.utils.TelnetUtil;
import com.lxzn.framework.utils.ValidateUtil;
import com.lxzn.framework.utils.date.DateUtil;
import com.lxzn.framework.utils.file.FileUtil;
import com.lxzn.nc.dao.DocInfoMapper;
import com.lxzn.nc.service.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Slf4j
@Service
public class DocInfoServiceImpl extends ServiceImpl<DocInfoMapper,DocInfo> implements IDocInfoService {
    @Autowired
    private IDocClassificationService docClassificationService;
    @Autowired
    private IDocFileService docFileService;
    @Autowired
    private IFileOperateService fileOperateService;
    @Autowired
    private IDocRelativeService docRelativeService;
    @Autowired
    private IDeviceInfoService deviceInfoService;
    @Autowired
    private IDeviceGroupService deviceGroupService;
    @Value("${securedoc.serverIp}")
    private String serverIp;
    @Value("${securedoc.serverPort}")
    private int serverPort;
    @Value("${securedoc.whether}")
    private String whether;
    @Value("${securedoc.localFilePath}")
    private String localFilePath;
    @Autowired
    private IDncPassLogService dncPassLogService;
    @Autowired
    private INcLogInfoService iNcLogInfoService;
    @Autowired
    private ISingleDictionaryService dictionaryService;

    /*备份处理*/
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDocInfo(MultipartFile file, DocInfoUploadRequest uploadRequest) {
        if(file == null || file.isEmpty() || uploadRequest == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(uploadRequest.getAttributionId()) || !ValidateUtil.validateInteger(uploadRequest.getAttributionType()))
            ExceptionCast.cast(DocumentCode.DOC_ATTRIBUTE_ERROR);
        if(!ValidateUtil.validateString(uploadRequest.getDocClassCode()))
            ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
        DocClassification docClass = docClassificationService.getByCode(uploadRequest.getDocClassCode());
        if(docClass == null)
            ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
        String fileName = FileUtil.getFilenameNonSuffix(file.getOriginalFilename());
        String fileNameAll = file.getOriginalFilename();
        DocInfo en = findByAttrAndDocName(fileName, uploadRequest.getAttributionType(), uploadRequest.getAttributionId());
        //针对存在的处理
        if(en != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_EXIST);
        FileUploadResult fileUploadResult = FileUtil.uploadFile(file);
        if(fileUploadResult == null)
            ExceptionCast.cast(DocumentCode.DOC_UPLOAD_ERROR);
        DocInfo docInfo = new DocInfo();
        String docId = IdWorker.getIdStr();
        docInfo.setDocId(docId);
        docInfo.setSyncStatus(2);
        docInfo.setDocName(fileUploadResult.getFileName());
        docInfo.setDocSuffix(fileUploadResult.getFileSuffix());
        docInfo.setDocStatus(1);
        DocRelative docRelative = new DocRelative();
        docRelative.setAttributionId(uploadRequest.getAttributionId());
        docRelative.setDocId(docInfo.getDocId());
        docRelative.setAttributionType(uploadRequest.getAttributionType());
        docRelative.setClassificationId(docClass.getClassificationId());
        boolean b = docRelativeService.save(docRelative);
        if(!b)
            ExceptionCast.cast(DocumentCode.DOC_UPLOAD_ERROR);
        DocFile docFile = new DocFile();
        docFile.setDocId(docInfo.getDocId());
        docFile.setFileName(fileUploadResult.getFileName());
        docFile.setFileEncodeName(fileUploadResult.getEncodeFileName());
        docFile.setFilePath(fileUploadResult.getFilePath());
        docFile.setFileSize(fileUploadResult.getFileSize());
        docFile.setFileSuffix(fileUploadResult.getFileSuffix());
        b =  docFileService.addDocFile(docFile);
        if(!b)
            ExceptionCast.cast(DocumentCode.DOC_UPLOAD_ERROR);
        docInfo.setPublishVersion(docFile.getDocVersion());
        docInfo.setPublishFileId(docFile.getFileId());
        //COPY
        DeviceInfo deviceInfo= deviceInfoService.getById(uploadRequest.getAttributionId());
        String sendOrRec = "send";
        if (uploadRequest.getDocClassCode().equals("REC")) {
            sendOrRec = "REC";
        }
        if (deviceInfo != null) {
            List<String> strings =  deviceGroupService.findListParentTreeAll(deviceInfo.getGroupId());
            boolean copyFileNc = false;
            if (strings != null && !strings.isEmpty()) {
                String path = org.apache.commons.lang3.StringUtils.join(strings.toArray(), "/");
                copyFileNc = FileUtil.copyFile(fileUploadResult.getFilePath()+"/" + fileUploadResult.getEncodeFileName(),
                        path+ "/" + deviceInfo.getDeviceNo() ,fileNameAll,sendOrRec);
                if (!copyFileNc) {
                    ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
                } else {
                    FileUtil.deleteZipFromToSend(path + "/"+ deviceInfo.getDeviceNo(),
                            docFile.getFileName(),docFile.getFileSuffix(),sendOrRec);

                }
            } else {
                copyFileNc =FileUtil.copyFile(fileUploadResult.getFilePath()+"/" + fileUploadResult.getEncodeFileName(),
                        deviceInfo.getDeviceNo() ,fileNameAll,sendOrRec);
                if (!copyFileNc) {
                    ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
                } else {
                    FileUtil.deleteZipFromToSend(fileUploadResult.getFilePath()+"/" + fileUploadResult.getEncodeFileName() + "/"+ deviceInfo.getDeviceNo(),
                            docFile.getFileName(),docFile.getFileSuffix(),sendOrRec);

                }
            }

        }
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("导入"+docClass.getClassificationName()+"，文档名称:"+(docFile.getFileName()+"."+docFile.getFileSuffix()));
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean saveBool = super.save(docInfo);
        return saveBool;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDocInfoRec(String pathFile,File fileRec) {
        // /dnc/NC/3140058/REC/
        if (StringUtils.isEmpty(pathFile)) {
            return false;
        }
        SingleDictionary singleDictionary=dictionaryService.findListFromTypeCode("virtual_equipment_id").get(0);
        MultipartFile file = FileUtil.fileToMultipartFile(fileRec);
        DocClassification docClass = docClassificationService.getByCode("REC");
        if(docClass == null) {
            ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
        }
        //根据设备编号查询数据
        Integer recNum = pathFile.lastIndexOf("/REC/");
        if (recNum == -1) {
            return false;
        }
        String  recF =  pathFile.substring(0,recNum);//将返回def}ab
        Integer equipmentId = recF.lastIndexOf("/");
        String deviceNo = recF.substring(equipmentId+1,recF.length());
        if (StringUtils.isEmpty(deviceNo)) {
            log.error("设备号为空");
            return false;
        }
        log.info("deviceNo ==== " + deviceNo);
        DeviceInfo deviceInfo = deviceInfoService.getByDeviceNo(deviceNo);
        if (deviceInfo == null) {
            return false;
        }

        String docEquipmentId = null;
        if (singleDictionary != null) {
            docEquipmentId= String.valueOf(singleDictionary.getDicValue());
        }
        List<String> strings =  deviceGroupService.findListParentTreeAll(deviceInfo.getGroupId());
        String fileSuffix = FileUtil.getFileSuffix(fileRec.getName());
        if ( !fileSuffix.equals("zip") && !fileSuffix.equals("rar") ) {
            //处理文件 记录并上报
            //1、 判断端口是否能够访问 文件路径加
//            boolean btelnetPort =  TelnetUtil.telnetPort(serverIp,serverPort,10);
//            if (!btelnetPort) {
//                ExceptionCast.cast(ActivitiCode.ACT_DEVICE_DOC_FILELABLE);
//            }
            DncPassLog passInfoTxt = new DncPassLog();

            String path = org.apache.commons.lang3.StringUtils.join(strings.toArray(), "/");
            Date dateFirst = DateUtil.getNow();
            passInfoTxt.setDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));

            //休眠 500毫秒
            DncPassLog dncPassLog  = dncPassLogService.findDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
            Integer fileTxt = 0, fileNc =0;
            if (dncPassLog !=null) {
                fileTxt = dncPassLog.getSequenceNumber() + 1;
                fileNc = fileTxt + 1;
            } else {
                fileTxt =  1;
                fileNc = fileTxt + 1;
            }
            //处理文件名称  文件路径
            String sequence = String.format("%06d",fileTxt);
            String sequenceNc = String.format("%06d",fileNc);
            passInfoTxt.setSequenceNumber(fileTxt);
            passInfoTxt.setSequenceOrder(sequence);
            passInfoTxt.setCreateTime(dateFirst);
            System.out.println(DateUtil.format(dateFirst,DateUtil.STR_DATE_TIME));
            passInfoTxt.setPassType("01");
            dncPassLogService.save(passInfoTxt);

            DncPassLog passInfoNc = new DncPassLog();
            passInfoNc.setSequenceNumber(fileNc);
            passInfoNc.setSequenceOrder(sequenceNc);
            passInfoNc.setDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
            passInfoNc.setPassType("02");
            passInfoNc.setPassName(fileRec.getName());
            try {
                Thread.sleep(1000);
                Date date = new Date();
                passInfoNc.setCreateTime(date);
                System.out.println(DateUtil.format(date,DateUtil.STR_DATE_TIME));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            dncPassLogService.save(passInfoNc);

            NcTxtFilePathInfo ncTxt = new NcTxtFilePathInfo();
            ncTxt.setEquipmentId(deviceInfo.getDeviceNo());
            if (deviceInfo.getDeviceNo().equals(docEquipmentId)) {
                //原有名称加时间
                ncTxt.setFileNcName(fileRec.getName()+"_"+DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
            }else {
                ncTxt.setFileNcName("10B"+DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY)+sequenceNc);
            }
            ncTxt.setFileTxtName("10B"+DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY)+sequence);
            ncTxt.setFilePath(path + "/"+ deviceInfo.getDeviceNo() + "/" );
            ncTxt.setOrigFileName(fileRec.getName());
            ncTxt.setOrigFileSuffix(fileSuffix);
            ncTxt.setFileAddOrDelete(1);
            String loFilePath = localFilePath + ncTxt.getFileTxtName() + ".nc";
            String size = String.valueOf(fileRec.length());

            try {
                String allList = new String();
                allList=(ncTxt.getFileTxtName()+"\n");
                allList+=(ncTxt.getFileNcName()+"\n");
                allList+=(ncTxt.getOrigFileName()+"\n");
                allList+=(ncTxt.getOrigFileSuffix()+"\n");
                allList+=(ncTxt.getFilePath()+"\n");
                allList+=(ncTxt.getEquipmentId()+"\n");
                allList+=(ncTxt.getFileAddOrDelete().toString()+"\n");
                // 文件大小字节  第二行 工控网进行文件分析
                allList+= (size+"\n");

                FileUtil.fileWriterSql(loFilePath,allList);

                //对比设备编号
                if (deviceInfo.getDeviceNo().equals(docEquipmentId)) {
                    String originalFilename = fileRec.getName();
                    File virtualDeviceDir = new File(localFilePath);
                    if (!virtualDeviceDir.exists() && !virtualDeviceDir.mkdirs()) {
                        log.error("无法创建虚拟设备目录: {}", virtualDeviceDir.getAbsolutePath());
                        return false;
                    }
                    // 3. 构建目标文件路径
                    File targetFile = new File(virtualDeviceDir, originalFilename);
                    try {
                        // 4. 使用NIO复制文件，并替换已存在的文件
                        //更换文件名，更换为ncTxt.getFileNcName()
                        Files.copy(
                                fileRec.toPath(),
                                targetFile.toPath(),
                                StandardCopyOption.REPLACE_EXISTING
                        );
                        log.info("虚拟设备文件已保存至: {}", targetFile.getAbsolutePath());
                    } catch (IOException e) {
                        log.error("虚拟设备文件保存失败", e);
                        return false;
                    }
                    return true;
                }else {
                    //文件解析重新规划
                    //添加文件名字，第一行
                    boolean copyFileNc = FileUtil.copyFileUpNameRec(fileRec,
                            localFilePath + ncTxt.getFileNcName(),
                            fileSuffix,"NC");
                    if (!copyFileNc) {
                        FileUtil.deleteNcFile(loFilePath);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String fileName = FileUtil.getFilenameNonSuffix(file.getOriginalFilename());
        FileUploadResult fileUploadResult = FileUtil.uploadFile(file);

        if(fileUploadResult == null) {
            return false;
        }
        DocInfo en = findByAttrAndDocName(fileName, 4, deviceInfo.getDeviceId());
        if(en != null) {
            return false;
        }

        DocInfo docInfo = new DocInfo();
        String docId = IdWorker.getIdStr();
        docInfo.setDocId(docId);
        docInfo.setDocName(fileUploadResult.getFileName());
        docInfo.setDocSuffix(fileUploadResult.getFileSuffix());
        docInfo.setDocStatus(2);
        DocRelative dr = new DocRelative();
        dr.setAttributionId(deviceInfo.getDeviceId());
        dr.setDocId(docInfo.getDocId());
        dr.setAttributionType(4);
        dr.setClassificationId(docClass.getClassificationId());
        try {
            boolean b = docRelativeService.save(dr);
            if(!b) {
                ExceptionCast.cast(DocumentCode.DOC_UPLOAD_ERROR);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        DocFile docFile = new DocFile();
        docFile.setDocId(docInfo.getDocId());
        docFile.setFileName(fileUploadResult.getFileName());
        docFile.setFileEncodeName(fileUploadResult.getEncodeFileName());
        docFile.setFilePath(fileUploadResult.getFilePath());
        docFile.setFileSize(fileUploadResult.getFileSize());
        docFile.setFileSuffix(fileUploadResult.getFileSuffix());
        docFile.setUpdateUser("11");
        boolean b =  docFileService.addDocFile(docFile);
        if(!b) {
            return false;
        }
        docInfo.setPublishVersion(docFile.getDocVersion());
        docInfo.setPublishFileId(docFile.getFileId());
        boolean saveBool = super.save(docInfo);
        return saveBool;

    }


    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editDocInfo(String id, DocInfo docInfo) {
        if(!ValidateUtil.validateString(id) || docInfo == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        DocInfo asDoc = findByAttrAndDocNameNotThis(docInfo.getDocName(), docInfo.getAttributionType(), docInfo.getAttributionId(), id);
        if(asDoc != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_EXIST);
        docInfo.setDocId(id);
        docInfo.setDocStatus(null);
        docInfo.setDocSuffix(null);
        docInfo.setClassificationId(null);
        docInfo.setPublishFileId(null);
        docInfo.setPublishVersion(null);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(3);
        //日志内容
        ncLogInfo.setLogContent("文档名称："+docInfo.getDocName());
        //修改保存备注
        ncLogInfo.setRemark(JSONObject.toJSONString(en));
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return super.updateById(docInfo);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(en.getDocStatus() != 1)
            ExceptionCast.cast(DocumentCode.DOC_DEL_ERROR);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_OPERATING);
        boolean b = docFileService.deleteByDocId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = docRelativeService.deleteByDocId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(4);
        //日志内容
        ncLogInfo.setLogContent("文档名称："+en.getDocName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return super.removeById(id);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean pushDocFile(String id, MultipartFile file) {
        if(file == null || file.isEmpty() || !ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        String userId = JwtUtil.getUserId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate == null || !userId.equals(operate.getCreateUser()))
            ExceptionCast.cast(DocumentCode.DOC_OPERATE_PUSH_FAIL);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        List<DeviceInfo> deviceList = docRelativeService.findDeviceByDocId(en.getDocId());
        if(deviceList != null && !deviceList.isEmpty())
            ExceptionCast.cast(DocumentCode.DOC_DEVICE_EXIST);
        String suffix = FileUtil.getFileSuffix(file.getOriginalFilename());
        if(ValidateUtil.validateString(en.getDocSuffix())) {
            if(!en.getDocSuffix().equals(suffix)) {
                ExceptionCast.cast(DocumentCode.DOC_SUFFIX_ERROR);
            }
        }else {
            if(ValidateUtil.validateString(suffix)) {
                ExceptionCast.cast(DocumentCode.DOC_SUFFIX_ERROR);
            }
        }
        FileUploadResult fileUploadResult = FileUtil.uploadFile(file);
        DocFile docFile = new DocFile();
        docFile.setDocId(id);
        docFile.setFileName(fileUploadResult.getFileName());
        docFile.setFileEncodeName(fileUploadResult.getEncodeFileName());
        docFile.setFilePath(fileUploadResult.getFilePath());
        docFile.setFileSize(fileUploadResult.getFileSize());
        docFile.setFileSuffix(fileUploadResult.getFileSuffix());
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("入库"+docFile.getFileSuffix()+"格式文档，文档名称:"+docFile.getFileName());
        ncLogInfo.setRemark(JSONObject.toJSONString(en));
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean b = fileOperateService.deleteByDocId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b=  docFileService.addDocFile(docFile);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        en.setPublishVersion(docFile.getDocVersion());
        en.setPublishFileId(docFile.getFileId());
        return super.updateById(en);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public DocFile checkDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(en.getDocStatus() != 1)
            ExceptionCast.cast(DocumentCode.DOC_OPERATE_FAIL);
        if(!ValidateUtil.validateString(en.getPublishFileId()))
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NONE);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_OPERATING);
        operate = new FileOperate();
        operate.setDocId(id);
        boolean b = fileOperateService.save(operate);
        if(!b)
            ExceptionCast.cast(DocumentCode.DOC_OPERATE_FAIL);
        DocFile fileInfo = docFileService.getById(en.getPublishFileId());
        if(fileInfo == null)
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NOT_EXIST);
        return fileInfo;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean publishDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(en.getDocStatus() != 1)
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_ERROR);
        if(!ValidateUtil.validateString(en.getPublishFileId()))
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NONE);
        DocFile pubFile = docFileService.getById(en.getPublishFileId());
        if(pubFile == null)
            ExceptionCast.cast(DocumentCode.DOC_FILE_ERROR);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_OPERATING);
        DocFile old = docFileService.getDocFileNearest(en.getDocId());
        if(old == null)
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NONE);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("发布"+en.getDocSuffix()+"格式文档，文档名称:"+en.getDocName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        if(old.getDocVersion().contains(".")) {
            DocFile docFile = new DocFile();
            BeanMapper.copy(pubFile, docFile);
            docFile.setFileId(null);
            docFile.setDocVersion(old.getDocVersion().substring(0, 1));
            boolean b =  docFileService.save(docFile);
            if(!b)
                ExceptionCast.cast(CommonCode.FAIL);
            return super.lambdaUpdate().eq(DocInfo::getDocId, id).set(DocInfo::getDocStatus, 2).set(DocInfo::getPublishFileId, docFile.getFileId())
                    .set(DocInfo::getPublishVersion, docFile.getDocVersion()).update();
        }else {
            return super.lambdaUpdate().eq(DocInfo::getDocId, id).set(DocInfo::getDocStatus, 2).set(DocInfo::getPublishFileId, old.getFileId())
                    .set(DocInfo::getPublishVersion, old.getDocVersion()).update();
        }
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean republishDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(en.getDocStatus() != 2)
            ExceptionCast.cast(DocumentCode.DOC_REPUBLISH_ERROR);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("重新发布"+en.getDocSuffix()+"格式文档，文档名称:"+en.getDocName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return super.lambdaUpdate().eq(DocInfo::getDocId, id).set(DocInfo::getDocStatus, 1).update();
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean pigeonholeDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(en.getDocStatus() == 3)
            ExceptionCast.cast(DocumentCode.DOC_PIGEONHOLE_ERROR);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate != null)
            ExceptionCast.cast(DocumentCode.DOC_IS_OPERATING);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("归档"+en.getDocSuffix()+"格式文档，文档名称:"+en.getDocName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return super.lambdaUpdate().eq(DocInfo::getDocId, id).set(DocInfo::getDocStatus, 3).update();
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean cancelPullDocInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        String userId = JwtUtil.getUserId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        FileOperate operate = fileOperateService.getByDocId(id);
        if(operate == null || !userId.equals(operate.getCreateUser()))
            ExceptionCast.cast(DocumentCode.DOC_CANCEL_PULL_ERROR);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("取消出库"+en.getDocSuffix()+"格式文档，文档名称:"+en.getDocName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return fileOperateService.deleteByDocId(id);
    }

    @Override
    public QueryPageResponseResult<DocInfo> findPageList(int page, int size, DocInfoQueryRequest docQuery) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        if(docQuery == null || !ValidateUtil.validateString(docQuery.getAttributionId())
                || !ValidateUtil.validateInteger(docQuery.getAttributionType()) ||
                !ValidateUtil.validateString(docQuery.getDocClassCode())) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        DocClassification docClassification = docClassificationService.getByCode(docQuery.getDocClassCode());
        if(docClassification == null) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<DocInfo> pageData = new Page<>(page, size);

//        LambdaQueryWrapper<DocInfo> lambdaQuery = Wrappers.lambdaQuery();
//        lambdaQuery.eq(DocInfo::getAttributionType, docQuery.getAttributionType()).eq(DocInfo::getAttributionId, docQuery.getAttributionId())
//                .eq(DocInfo::getClassificationId, docClassification.getClassificationId());
        QueryWrapper<DocInfo> queryWrapper = Wrappers.query();
        queryWrapper.eq("r.attribution_type", docQuery.getAttributionType()).eq("r.attribution_id", docQuery.getAttributionId())
                .eq("r.classification_id", docClassification.getClassificationId());
        if (StringUtils.isNotEmpty(docQuery.getDocName())) {
            int dotIndex = docQuery.getDocName().lastIndexOf(".");
            if (dotIndex == -1) {
                queryWrapper.like("u.doc_name", docQuery.getDocName());
            } else {
                String[] docNameArr = docQuery.getDocName().split("\\.");
                queryWrapper.like(StrUtil.isNotEmpty(docNameArr[0]), "u.doc_name", docNameArr[0]);
                queryWrapper.eq(StrUtil.isNotEmpty(docNameArr[1]), "u.doc_suffix", docNameArr[1]);
            }
        }
        queryWrapper.ge(StrUtil.isNotEmpty(docQuery.getStartTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getStartTime());
        queryWrapper.le(StrUtil.isNotEmpty(docQuery.getEndTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getEndTime());
        if(ValidateUtil.validateString(docQuery.getAscStr())) {
            String[] ascArr = docQuery.getAscStr().split(",");
            ((Page<DocInfo>) pageData).setAsc(ascArr);
        }
        if(ValidateUtil.validateString(docQuery.getDescStr())) {
            String[] descStr = docQuery.getDescStr().split(",");
            ((Page<DocInfo>) pageData).setDesc(descStr);
        }
        IPage<DocInfo> docInfoIPage = super.getBaseMapper().findDocExtList(pageData, queryWrapper);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, docInfoIPage);
    }

    @Override
    public DocInfo getByDocAttrAndDocId(String docId, Integer attrType, String attributeId) {
        if(!ValidateUtil.validateString(docId) || !ValidateUtil.validateString(attributeId) || !ValidateUtil.validateInteger(attrType))
            return null;
        List<DocInfo> list = super.getBaseMapper().getByDocAttrAndDocId(docId, attrType, attributeId);
        if(list == null || list.size() != 1)
            return null;
        return list.get(0);
    }

    @Override
    public DocFile previewDocFile(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        DocFile fileInfo = docFileService.getById(en.getPublishFileId());
        if(fileInfo == null)
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NOT_EXIST);
        return fileInfo;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByProductId(String productId) {
        if(!ValidateUtil.validateString(productId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Integer attrType = 1;
        boolean b = docFileService.deleteByDocAttr(attrType, productId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = deleteByDocAttr(attrType, productId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return docRelativeService.deleteByDocAttr(attrType, productId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByComponentId(String componentId) {
        if(!ValidateUtil.validateString(componentId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Integer attrType = 2;
        boolean b = docFileService.deleteByDocAttr(attrType, componentId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = deleteByDocAttr(attrType, componentId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return docRelativeService.deleteByDocAttr(attrType, componentId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByPartsId(String partsId) {
        if(!ValidateUtil.validateString(partsId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Integer attrType = 3;
        boolean b = docFileService.deleteByDocAttr(attrType, partsId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = deleteByDocAttr(attrType, partsId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return docRelativeService.deleteByDocAttr(attrType, partsId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByDeviceId(String deviceId) {
        if(!ValidateUtil.validateString(deviceId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Integer attrType = 4;
        /*boolean b = docFileService.deleteByDocAttr(attrType, deviceId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = deleteByDocAttr(attrType, deviceId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);*/
        return docRelativeService.deleteByDocAttr(attrType, deviceId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByProcessId(String processId) {
        if(!ValidateUtil.validateString(processId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Integer attrType = 4;
        boolean b = docFileService.deleteByDocAttr(attrType, processId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = deleteByDocAttr(attrType, processId);
        if(!b) {
            ExceptionCast.cast(CommonCode.FAIL);
        }
        return docRelativeService.deleteByDocAttr(attrType, processId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByDocAttr(Integer attrType, String attrId) {
        int i = super.getBaseMapper().deleteByDocAttr(attrType, attrId);
        if(i >= 0) {
            return true;
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResult pullDocFile(HttpServletRequest request, HttpServletResponse response, String id) {
        DocFile docFile = checkDocInfo(id);
        if(!ValidateUtil.validateString(docFile.getFilePath()) || !ValidateUtil.validateString(docFile.getFileName()) ||
                /*!ValidateUtil.validateString(docFile.getFileSuffix()) ||*/ !ValidateUtil.validateString(docFile.getFileEncodeName()))
            return new ResponseResult(CommonCode.FAIL);
        String fileName;
        if(ValidateUtil.validateString(docFile.getFileSuffix())) {
            fileName = docFile.getFileName() + "." + docFile.getFileSuffix();
        }else {
            fileName = docFile.getFileName();
        }
        String filePath = docFile.getFilePath();
        String fileEncodeName = docFile.getFileEncodeName();
        FileUtil.downLoadFile(response, fileEncodeName, filePath, fileName);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("设备结构树");
        //类型
        ncLogInfo.setOperateType(7);
        //日志内容
        ncLogInfo.setLogContent("出库"+docFile.getFileSuffix()+"格式文档，文档名称:"+fileName);
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return null;
    }

    @Override
    public DocInfo findByAttrAndDocName(String docName, Integer attrType, String attrId) {
        List<DocInfo> docInfoList = super.getBaseMapper().findByAttrAndDocName(docName, attrType, attrId);
        if(docInfoList == null || docInfoList.isEmpty())
            return null;
        return docInfoList.get(0);
    }

    @Override
    public DocInfo findByAttrAndDocNameNotThis(String docName, Integer attrType, String attrId, String docId) {
        List<DocInfo> docInfoList = super.getBaseMapper().findByAttrAndDocName(docName, attrType, attrId);
        if(docInfoList == null || docInfoList.isEmpty())
            return null;
        for(DocInfo docInfo : docInfoList) {
            if(!docId.equals(docInfo.getDocId())) {
                return docInfo;
            }
        }
        return null;
    }

    @Override
    public List<DocInfo> getByDocId(String docId) {
        return super.getBaseMapper().getByDocId(docId);
    }

    @Override
    public QueryPageResponseResult<DocInfo> findPageListByDevice(int page, int size, DocInfoQueryRequest docQuery) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        if(docQuery == null || !ValidateUtil.validateString(docQuery.getAttributionId())
                || !ValidateUtil.validateInteger(docQuery.getAttributionType()) ||
                !ValidateUtil.validateString(docQuery.getDocClassCode())) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        DocClassification docClassification = docClassificationService.getByCode(docQuery.getDocClassCode());
        if(docClassification == null) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<DocInfo> pageData = new Page<>(page, size);
        QueryWrapper<DocInfo> queryWrapper = Wrappers.query();
        queryWrapper.eq("r.attribution_type", docQuery.getAttributionType())
                .eq("r.attribution_id", docQuery.getAttributionId())
                .eq("r.classification_id", docClassification.getClassificationId());
        if (StringUtils.isNotEmpty(docQuery.getDocName())) {
            int dotIndex = docQuery.getDocName().lastIndexOf(".");
            if (dotIndex == -1) {
                queryWrapper.like("u.doc_name", docQuery.getDocName());
            } else {
                String[] docNameArr = docQuery.getDocName().split("\\.");
                queryWrapper.like(StrUtil.isNotEmpty(docNameArr[0]), "u.doc_name", docNameArr[0]);
                queryWrapper.eq(StrUtil.isNotEmpty(docNameArr[1]), "u.doc_suffix", docNameArr[1]);
            }
        }
        queryWrapper.ge(StrUtil.isNotEmpty(docQuery.getStartTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getStartTime());
        queryWrapper.le(StrUtil.isNotEmpty(docQuery.getEndTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getEndTime());

        if(ValidateUtil.validateString(docQuery.getAscStr())) {
            String[] ascArr = docQuery.getAscStr().split(",");
            ((Page<DocInfo>) pageData).setAsc(ascArr);
        }
        if(ValidateUtil.validateString(docQuery.getDescStr())) {
            String[] descStr = docQuery.getDescStr().split(",");
            ((Page<DocInfo>) pageData).setDesc(descStr);
        }
        IPage<DocInfo> docInfoIPage = super.getBaseMapper().findDeviceDocExtList(pageData, queryWrapper);
        if (docInfoIPage != null && docInfoIPage.getRecords() != null && !docInfoIPage.getRecords().isEmpty()) {
            for (DocInfo d : docInfoIPage.getRecords()) {
                d.setSyncStatus(2);
            }
        }
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, docInfoIPage);
    }

    @Override
    public QueryListResponseResult<DocInfo> findList(DocInfoQueryRequest docQuery) {
        if(docQuery == null || !ValidateUtil.validateString(docQuery.getAttributionId())
                || !ValidateUtil.validateInteger(docQuery.getAttributionType()) ||
                !ValidateUtil.validateString(docQuery.getDocClassCode())) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        DocClassification docClassification = docClassificationService.getByCode(docQuery.getDocClassCode());
        if(docClassification == null) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }

        QueryWrapper<DocInfo> queryWrapper = Wrappers.query();
        queryWrapper.eq("r.attribution_type", docQuery.getAttributionType()).eq("r.attribution_id", docQuery.getAttributionId())
                .eq("r.classification_id", docClassification.getClassificationId());
        if (StringUtils.isNotEmpty(docQuery.getDocName())) {
            int dotIndex = docQuery.getDocName().lastIndexOf(".");
            if (dotIndex == -1) {
                queryWrapper.like("u.doc_name", docQuery.getDocName());
            } else {
                String[] docNameArr = docQuery.getDocName().split("\\.");
                queryWrapper.like(StrUtil.isNotEmpty(docNameArr[0]), "u.doc_name", docNameArr[0]);
                queryWrapper.eq(StrUtil.isNotEmpty(docNameArr[1]), "u.doc_suffix", docNameArr[1]);
            }
        }
        queryWrapper.ge(StrUtil.isNotEmpty(docQuery.getStartTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getStartTime());
        queryWrapper.le(StrUtil.isNotEmpty(docQuery.getEndTime()),"date_format(u.create_time,'%Y-%m-%d %H:%i:%s')",docQuery.getEndTime());
        List<DocInfo> docInfoIPage = super.getBaseMapper().findDocExtList(queryWrapper);
        return new QueryListResponseResult<>(CommonCode.SUCCESS, docInfoIPage);
    }

    @Override
    public List<DocInfo> getByProcessIds(List<ProcessStream> streams) {
        List<String> ids = new ArrayList<>();
        for(ProcessStream s : streams) {
            ids.add(s.getProcessId());
        }
        DocClassification docClassification = docClassificationService.getByCode("NC");
        if(docClassification == null) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        QueryWrapper<DocInfo> queryWrapper = Wrappers.query();
        queryWrapper.in("r.attribution_id", ids)
                .eq("r.classification_id", docClassification.getClassificationId())
        .ne("u.doc_status", 3).isNotNull("u.publish_file_id");
        return super.getBaseMapper().findDocExtList(queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean batchRemoveDocInfo(String[] docIds) {
        if(docIds == null || docIds.length < 1)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        for(String docId : docIds) {
            this.deleteDocInfo(docId);
        }
        return true;
    }

    @Override
    public ResponseResult downloadDocFile(HttpServletRequest request, HttpServletResponse response, String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        DocInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        if(!ValidateUtil.validateString(en.getPublishFileId()))
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NONE);
        DocFile docFile = docFileService.getById(en.getPublishFileId());
        if(docFile == null)
            ExceptionCast.cast(DocumentCode.DOC_PUBLISH_FILE_NOT_EXIST);
        if(!ValidateUtil.validateString(docFile.getFilePath()) || !ValidateUtil.validateString(docFile.getFileName()) ||
                /*!ValidateUtil.validateString(docFile.getFileSuffix()) ||*/ !ValidateUtil.validateString(docFile.getFileEncodeName()))
            return new ResponseResult(CommonCode.FAIL);
        String fileName;
        if(ValidateUtil.validateString(docFile.getFileSuffix())) {
            fileName = docFile.getFileName() + "." + docFile.getFileSuffix();
        }else {
            fileName = docFile.getFileName();
        }
        String filePath = docFile.getFilePath();
        String fileEncodeName = docFile.getFileEncodeName();
        FileUtil.downLoadFile(response, fileEncodeName, filePath, fileName);
        return null;
    }
}