4dkankan-center-modeling-control/src/main/java/com/fdkankan/contro/mq/service/impl/BuildSxTestServiceImpl.java

package com.fdkankan.contro.mq.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fdkankan.common.constant.*;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.contro.entity.*;
import com.fdkankan.contro.mq.service.IBuildSceneService;
import com.fdkankan.contro.service.*;
import com.fdkankan.fyun.config.FYunFileConfig;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.model.constants.ConstantFileName;
import com.fdkankan.model.constants.ConstantFilePath;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.model.enums.ModelTypeEnums;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.model.utils.SceneUtil;
import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
import com.fdkankan.rabbitmq.bean.BuildSceneResultMqMessage;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.*;


/**
 * <p>
 * TODO
 * </p>
 *
 * @author dengsixing
 * @since 2022/4/20
 **/
@Slf4j
@Service
@RefreshScope
public class BuildSxTestServiceImpl implements IBuildSceneService {

    @Value("${queue.modeling.modeling-call}")
    private String queueModelingCall;
    @Value("${queue.modeling.sx.modeling-sx-post:modeling-sx-post}")
    private String queueModelingPost;
    @Value("${model.type:#{null}}")
    private String modelType;
    @Value("${env:gn}")
    private String env;
    @Value("#{'${build.scene.post.not-delete-nas-nums:}'.split(',')}")
    private List<String> notDeleteNasNumList;
    @Autowired
    private RabbitMqProducer mqProducer;
    @Resource
    private FYunFileServiceInterface fYunFileService;
    @Autowired
    private FYunFileConfig fYunFileConfig;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private IScenePlusExtService scenePlusExtService;
    @Autowired
    private IBuildSceneDTService buildSceneDTService;
    @Autowired
    private ICommonService commonService;
    @Autowired
    private ISceneColdStorageService sceneColdStorageService;
    @Autowired
    private IntermitSceneService intermitSceneService;
    @Autowired
    private IBuildService buildService;

    @Override
    public void buildScenePre(BuildSceneCallMessage message) throws Exception{
        String num = message.getSceneNum();
        ScenePlus scenePlusByNum = scenePlusService.getScenePlusByNum(num);
        Map<String, Object> ext = message.getExt();
        String qjkkNum = (String)ext.get("qjkkNum");
        try {
            //重新计算时需要删除文件夹，否知使用缓存
            if(new File(message.getPath() + File.separator + "results").exists()){
                FileUtils.deleteDirectory(message.getPath() + File.separator + "results");
            }
            //由于刘强说caches会影响计算结果,所以这里删除caches
            if(new File(message.getPath() + File.separator + "caches").exists()){
                FileUtils.deleteDirectory(message.getPath() + File.separator + "caches");
            }

            //下载文件

//            //删除点位校准数据
//            if (Objects.nonNull(message.getExt())
//                    && message.getExt().containsKey("deleteExtras")
//                    && (Boolean) message.getExt().get("deleteExtras")) {
//                String extras = String.format(UploadFilePath.scene_result_data_path, num).concat("extras");
//                if(CollUtil.isNotEmpty(fYunFileService.listRemoteFiles(extras))){
//                    fYunFileService.deleteFolder(extras);
//                }
//            }

            //用户相机重新全量上传，需要解冻结
//            sceneColdStorageService.unfreeze(num, "用户相机重新全量上传", message.getPath());

            //根据相机类型，组装资源路径
            //下载资源到本地
//            this.downLoadSource(message, message.getPath());

            //下载深巡的pose文件夹，并重命名为extras
            Integer relocationMaxindex = scenePlusByNum.getRelocationMaxindex();
            if(relocationMaxindex == null){
                relocationMaxindex = -1;
            }
            String extrasPath = message.getPath() + "/extras/";
            fYunFileService.downloadFileByCommand(extrasPath, String.format(UploadFilePath.scene_result_data_path, num) + "pose/");
            List<String> imgKeyList = fYunFileService.listRemoteFiles(String.format(UploadFilePath.IMG_VIEW_PATH, qjkkNum) + "panoramas/");
            JSONObject query = new JSONObject();
            JSONArray queryList = new JSONArray();
            query.put("query", queryList);
            for (String key : imgKeyList) {
                String fileName = (++relocationMaxindex) + "." + FileUtil.extName(key);
                fYunFileService.downloadFile(key, extrasPath + "images/query/" + fileName);
                JSONObject fileNameObj = new JSONObject();
                fileNameObj.put("filename", fileName);
                queryList.add(fileNameObj);
            }
            //写query.json
            FileUtil.writeUtf8String(query.toJSONString(), extrasPath + "query.json");
            message.getExt().put("relocationMaxindex", relocationMaxindex);

            //发送mq，就进行计算
            message.setResultReceiverMqName(queueModelingPost);

            ScenePlusExt scenePlusExtByPlusId = scenePlusExtService.getScenePlusExtByPlusId(scenePlusByNum.getId());
            String dataFdageKey = SceneUtil.getHomePath(scenePlusExtByPlusId.getDataSource()) + "data.fdage";
            JSONObject jsonObject = JSON.parseObject(fYunFileService.getFileContent(dataFdageKey));
//            Map<String, String> dataMap = buildService.getTypeString(message.getCameraType(), message.getAlgorithm(), message.getResolution(),jsonObject);
            Map<String, String> dataMap = new HashMap<>();
            dataMap.put("splitType", "SPLIT_V31");
            dataMap.put("skyboxType", "SKYBOX_V6");
            buildService.writeDataJson(message, jsonObject, dataMap, null);
            log.info("场景计算资源准备结束，场景码：{}", message.getSceneNum());

        }catch (Exception e){
            log.error("场景计算前置处理出错,num"+num, e);
            scenePlusByNum.setSceneStatus(SceneStatus.FAILD.code());
            scenePlusService.updateById(scenePlusByNum);
            buildSceneDTService.handBaseFail("深巡场景重定向资源准备异常！", message.getPath(), message.getSceneNum(), "计算控制服务器");
            throw e;
        }
    }

    private String getOssPath(String path) {
        String ossPath = ConstantFilePath.OSS_PREFIX
                + path.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
                .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "");
        if (!ossPath.endsWith("/")) {
            ossPath = ossPath.concat("/");
        }
        return ossPath;
    }

    @Override
    public void downLoadSource(BuildSceneCallMessage buildSceneMqMessage,String path){
        String ossPath = getOssPath(path);
        fYunFileService.downloadFileByCommand(path + File.separator + "capture", ossPath);
    }

    @Override
    public void buildScenePost(BuildSceneResultMqMessage message) throws Exception {
        String sceneCode = message.getBuildContext().get("sceneNum").toString();
        String path = message.getPath();
        try {
            // 上传计算日志
            //如果是重复计算，没有走到计算逻辑，不需要上传日志文件
            log.info("开始上传计算日志");
            String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, sceneCode);
            fYunFileService.uploadFile(path + File.separator + "console.log", buildLogPath + "console.log");
            log.info("计算日志上传完成");

            if (!message.getBuildSuccess()) {
                log.error("建模失败，修改状态为失败状态");
                scenePlusService.update(new LambdaUpdateWrapper<ScenePlus>()
                        .set(ScenePlus::getSceneStatus, SceneStatus.FAILD.code())
                        .eq(ScenePlus::getNum, sceneCode));

//                //计算失败通知激光系统修改状态
//                fdkkLaserService.updateStatus(sceneCode, 1);

                // 发送钉钉消息，计算失败
                buildSceneDTService.handModelFail("深巡场景重定向计算失败", message.getPath(), sceneCode, message.getHostName());
                return;
            }
//            JSONObject fdageData = commonService.getFdageData(path + File.separator + "capture" +File.separator+"data.fdage");

            ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneCode);

            Map<String, String> uploadFiles = this.getUploadFiles(scenePlus,path);

            scenePlus.setPayStatus(PayStatus.PAY.code());
            scenePlus.setUpdateTime(new Date());
            scenePlus.setSceneStatus(SceneStatus.NO_DISPLAY.code());

//            Integer videoVersion = fdageData.getInteger("videoVersion");
            //读取计算结果文件生成videosJson
//            JSONObject videosJson = commonService.getVideosJson(path, videoVersion, sceneCode, cameraType);

            ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
//            boolean isObj = fdageData.containsKey("exportMeshObj") && fdageData.getIntValue("exportMeshObj") == 1;

            //上传全景图俯视图
//            this.uploadFloorCad(path, sceneCode, uploadFiles);

            log.info("开始上传场景计算结果数据，num:{}", sceneCode);
            //由于3dtiles算法mesh文件发生变化，所以这里需要先清除一下oss的mesh目录，避免存在旧算法obj文件
//            fYunFileService.deleteFolder(String.format(UploadFilePath.DATA_VIEW_PATH, sceneCode) + "mesh");
//            fYunFileService.deleteFolder(String.format(UploadFilePath.IMG_VIEW_PATH,  sceneCode) + ModelKind.THREE_D_TILE.code());
            //上传文件
            fYunFileService.uploadMulFiles(uploadFiles);

            //发送消息到点云系统处理
            Map<String, String> aa = new HashMap<>();
            aa.put("sceneCode", sceneCode);
            aa.put("path", path);
            mqProducer.sendByWorkQueue("laser-relocation-scene", aa);

            //修改oss上dam的内容编码
//            Map<String,String> damFileHeaders = new HashMap<>();
//            damFileHeaders.put("Content-Encoding","gzip");
//            String damPath = path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam";
//            fYunFileService.uploadFile(damPath,  String.format(UploadFilePath.IMG_VIEW_PATH, sceneCode) + ConstantFileName.modelUUID + "_50k.dam", damFileHeaders);

            //拷贝部分文件到编辑目录，用于用户编辑
//            this.copyToEditDir(sceneCode);

            //计算完毕后，同步全景图到缓存目录
//            this.cachePanorama(path, sceneCode);

            //生成houseTypejson并上传
//            boolean existHouseType = this.uploadHouseTypeJson(sceneCode, path);
//            scenePlus.setHouseType(existHouseType ? CommonStatus.YES.code().intValue() : CommonStatus.NO.code().intValue());

            //生成floorpan.json
//            commonService.uploadFloorplanJson(sceneCode, path);

            //重置异步操作记录
//            commonService.removeSceneAsynOperLog(sceneCode);

            //清除用户编辑业务数据
//            Set<String> bizs = new HashSet<>();
//            bizs.add(UserEditDataType.BOX_MODEL.message());
//            bizs.add(UserEditDataType.FLOORPLAN.message());
//            bizs.add(UserEditDataType.FILTERS.message());
//            commonService.initUserEditData(sceneCode, bizs, null);

            //上传计算结果文件
//            commonService.uploadBuildResultData(sceneCode, path, SceneVersionType.V4.code());

            //容量统计
            Long space = commonService.getSpace(sceneCode);

            //ai识别
//            aiService.detectScenePano(scenePlus, scenePlusExt, path);

            //写入数据库
//            this.updateDbPlus(scenePlus, scenePlusExt, space, videosJson.toJSONString(), message.getComputeTime(),isObj);

            Object[] editInfoArr = commonService.updateEditInfo(scenePlus);
            SceneEditInfo sceneEditInfo = (SceneEditInfo)editInfoArr[0];
            SceneEditInfoExt sceneEditInfoExt = (SceneEditInfoExt)editInfoArr[1];
            SceneEditControls sceneEditControls = (SceneEditControls)editInfoArr[2];

            //如果相机容量不足，需要把场景的paystatus改为容量不足状态
            scenePlus.setPayStatus(commonService.getPayStatus(scenePlus.getCameraId(), space, new JSONObject()));
            //统计原始资源大小
//            scenePlusExt.setOrigSpace(FileUtil.size(new File(path.concat(File.separator).concat("capture"))));


            log.info("生成scene.json上传oss并设置缓存，num:{}", sceneCode);
//            CameraDetail cameraDetail = cameraDetailService.getByCameraId(scenePlus.getCameraId());
//            Company company = !ObjectUtils.isEmpty(cameraDetail.getCompanyId()) ? companyService.getById(cameraDetail.getCompanyId()) : null;
            //写scene.json
//            commonService.writeSceneJson(sceneCode,sceneEditInfo, sceneEditInfoExt, sceneEditControls, scenePlus,scenePlusExt,company);

//            String qrLogo = !ObjectUtils.isEmpty(company) && !ObjectUtils.isEmpty(company.getQrLogo()) ? company.getQrLogo() : null;
//
//            qrLogo = ObjectUtils.isEmpty(qrLogo) && !ObjectUtils.isEmpty(sceneEditInfoExt.getShareLogoImg()) ? fYunFileConfig.getHost().concat(sceneEditInfoExt.getShareLogoImg()) : null;
//
//            createQrCode(sceneCode, scenePlusExt, qrLogo);
//
//            //计算成功，通知APP
//            Integer pushChannel = fdageData.getInteger("pushChannel");
//            String pushToken = fdageData.getString("pushToken");
//            this.pushMsgToApp(pushChannel,pushToken, cameraType, scenePlus.getTitle(), scenePlusExt.getWebSite());

//            //删除计算目录
//            if(CollUtil.isEmpty(notDeleteNasNumList) || !notDeleteNasNumList.contains(sceneCode)){
//                CreateObjUtil.deleteFile(path.replace(ConstantFilePath.BUILD_MODEL_PATH, "/"));
//            }


            this.uploadStatusJson(scenePlus, scenePlusExt);

            scenePlusService.updateById(scenePlus);
            scenePlusExtService.updateById(scenePlusExt);

            //国际环境需要发邮件通知
            if("eur".equals(env) &&
                    !scenePlus.getSceneSource().equals(SceneSource.JG.code()) &&
                    !scenePlus.getSceneSource().equals(SceneSource.SG.code())){
                commonService.sendEmail(sceneCode, "relocation");
            }

            //发送到文保系统
//            wbService.sendMq(sceneCode, CommonSuccessStatus.SUCCESS.code());

            //四川日报打包消费
//            this.sendMqToPackScene4Scrb(sceneCode);

            log.info("场景计算结果处理结束，场景码：{}", sceneCode);

        }catch (Exception e){
            log.error("场景计算结果处理出错,num"+sceneCode, e);

            //计算失败通知激光系统修改状态
//            fdkkLaserService.updateStatus(sceneCode, 1);

            buildSceneDTService.handBaseFail("场景计算结果处理出错！", message.getPath(), sceneCode, "计算控制服务器");
            throw e;
        }
    }

    private Map<String, String> getUploadFiles(ScenePlus scenePlus,String path) throws Exception {
        if (ObjectUtils.isEmpty(scenePlus)) {
            throw new Exception("未找到场景信息：" + path);
        }

        String projectNum = scenePlus.getNum();

        String dataViewPath = String.format(UploadFilePath.DATA_VIEW_PATH, projectNum);
        String imagesPath = String.format(UploadFilePath.IMG_VIEW_PATH, projectNum);
        String videoPath = String.format(UploadFilePath.VIDEOS_VIEW_PATH, projectNum);
        String resultsPath = path + File.separator + "results" + File.separator;

        String uploadData = FileUtils.readFile(resultsPath + "upload.json");
        JSONArray array = JSONObject.parseObject(uploadData).getJSONArray("upload");

        JSONObject fileJson = null;
        String fileName = "";

        Map<String, String> map = new HashMap();

        for (int i = 0; i < array.size(); ++i) {
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            String filePath = resultsPath + fileName;

            if (!(new File(filePath)).exists()) {
                throw new Exception(filePath + "文件不存在");
            }

            if ("vision2.txt".equals(fileName)) {
                CreateObjUtil.convertTxtToVisionmodeldata(resultsPath + "vision2.txt", resultsPath + "vision2.modeldata");
                map.put(resultsPath + "vision2.modeldata", imagesPath + "vision2.modeldata");
                map.put(resultsPath + "vision2.txt", imagesPath + "vision2.txt");
            }

            if (fileJson.getIntValue("clazz") == 2) {
                map.put(filePath, imagesPath + ConstantFileName.modelUUID + "_50k_texture_jpg_high1/" + fileName.replace("tex/", ""));
            } else if (fileJson.getIntValue("clazz") == 3) {
                map.put(filePath, imagesPath + "pan/high/" + fileName.replace("high/", ""));
            } else if (fileJson.getIntValue("clazz") == 4) {
                map.put(filePath, imagesPath + "pan/low/" + fileName.replace("low/", ""));
            } else if (fileJson.getIntValue("clazz") == 5) {
                map.put(filePath, imagesPath + fileName);
            } else if (fileJson.getIntValue("clazz") == 7) {
                map.put(filePath, imagesPath + fileName);
            } else if (fileJson.getIntValue("clazz") == 10) {
                String updown = FileUtils.readFile(filePath);
                JSONObject updownJson = JSONObject.parseObject(updown);
                String mappingOssPath = String.format("scene_edit_data/%s/data/", projectNum) + fileName.replace("updown", "mapping");
                map.put(filePath, mappingOssPath);
            } else {
                if (fileJson.getIntValue("clazz") == 11 || fileJson.getIntValue("clazz") == 12) {
                    map.put(filePath, videoPath + fileName.replace("videos/", ""));
                    if (fileName.contains(".mp4")) {
                        map.put(resultsPath + fileName.replace("mp4", "flv"), videoPath + fileName.replace("videos/", "").replace("mp4", "flv"));
                    }
                }

                if (fileJson.getIntValue("clazz") == 16) {
                    map.put(filePath, dataViewPath + fileName);
                }

                if (fileJson.getIntValue("clazz") == 18) {
                    map.put(filePath, imagesPath + fileName);
                }
            }
        }

        CreateObjUtil.convertTxtToVisionmodeldata(resultsPath + "vision.txt", resultsPath + "vision.modeldata");
        map.put(resultsPath + "vision.txt", imagesPath + "vision.txt");
        map.put(resultsPath + "vision.modeldata", imagesPath + "vision.modeldata");
        return map;
    }

    private void uploadStatusJson(ScenePlus scenePlus, ScenePlusExt scenePlusExt){
        String num = scenePlus.getNum();
        String dataViewPath = String.format(UploadFilePath.DATA_VIEW_PATH, num);

        Integer status = 1;
        // 上传status JSON.
        JSONObject statusJson = new JSONObject();
        //临时将-2改成1，app还没完全更新
        statusJson.put("status", status);
        statusJson.put("webSite", scenePlusExt.getWebSite());
        statusJson.put("sceneNum", num);
        statusJson.put("thumb", scenePlusExt.getThumb());
        statusJson.put("payStatus", scenePlus.getPayStatus());
        statusJson.put("sceneScheme", scenePlusExt.getSceneScheme());
        FileUtils.writeFile(ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json", statusJson.toString());

        fYunFileService.uploadFile(statusJson.toJSONString().getBytes(StandardCharsets.UTF_8), dataViewPath + "status.json");
    }

    private void updateDbPlus(int sceneSource,Long space,String videosJson, Long computeTime,boolean isObj,ScenePlusExt scenePlusExt){

        scenePlusExt.setSpace(space);
        scenePlusExt.setComputeTime(computeTime);
        scenePlusExt.setAlgorithmTime(new Date());
        scenePlusExt.setVideos(videosJson);
        scenePlusExt.setIsObj(isObj ? 1 : 0);

        if(ModelTypeEnums.TILE_CODE.equals(modelType)){
            scenePlusExt.setSceneScheme(3);
        }

        switch (SceneSource.get(sceneSource)){
            case BM:
                scenePlusExt.setSceneResolution(SceneResolution.two_K.code());
                scenePlusExt.setSceneFrom(SceneFrom.PRO.code());
                break;
            case SM:
                scenePlusExt.setSceneResolution(SceneResolution.one_k.code());
                scenePlusExt.setSceneFrom(SceneFrom.LITE.code());
                break;
            case ZT:
                scenePlusExt.setSceneResolution(SceneResolution.four_K.code());
                scenePlusExt.setSceneFrom(SceneFrom.MINION.code());
                break;
            case JG:
                scenePlusExt.setSceneResolution(SceneResolution.four_K.code());
                scenePlusExt.setSceneFrom(SceneFrom.LASER.code());
                break;
            case SG:
                scenePlusExt.setSceneResolution(SceneResolution.four_K.code());
                scenePlusExt.setSceneFrom(SceneFrom.LASER.code());
                break;
        }

        String sceneKind = scenePlusExt.getSceneScheme() == 3 ? SceneKind.FACE.code():SceneKind.TILES.code();
        scenePlusExt.setSceneKind(sceneKind);
//        scenePlusExt.setModelKind(modelKind);

        //统计点位数量
        scenePlusExt.setShootCount(this.getShootCount(scenePlusExt));

        scenePlusExtService.updateById(scenePlusExt);
    }

    private Integer getShootCount(ScenePlusExt scenePlusExt){
        Integer shootCount = null;
        String homePath = SceneUtil.getHomePath(scenePlusExt.getDataSource());
        JSONObject dataFdageObj = JSON.parseObject(fYunFileService.getFileContent(homePath.concat("data.fdage")));
        if(Objects.nonNull(dataFdageObj)){
            JSONArray points = dataFdageObj.getJSONArray("points");
            if(CollUtil.isNotEmpty(points)){
                shootCount = points.size();
            }
        }
        if(Objects.nonNull(shootCount) && shootCount > 0){
            return shootCount;
        }

        String slamDataStr = fYunFileService.getFileContent(homePath.concat("slam_data.json"));
        JSONObject slamDataObj = JSON.parseObject(slamDataStr);
        if(Objects.nonNull(slamDataObj)){
            JSONArray viewsInfo = slamDataObj.getJSONArray("views_info");
            if(CollUtil.isNotEmpty(viewsInfo)){
                shootCount = viewsInfo.stream().mapToInt(info -> {
                    return  ((JSONObject) info).getJSONArray("list_pose").size();
                }).sum();
            }
        }

        return shootCount;
    }


}