//package com.fdkankan.modeling.receiver;
//
//import static com.fdkankan.push.PushMessageConfig.ANDROID_KEY;
//import static com.fdkankan.push.PushMessageConfig.ANDROID_KEY_Z;
//import static com.fdkankan.push.PushMessageConfig.ANDROID_SECRET;
//import static com.fdkankan.push.PushMessageConfig.ANDROID_SECRET_Z;
//import static com.fdkankan.push.PushMessageConfig.IOS_KEY;
//import static com.fdkankan.push.PushMessageConfig.IOS_KEY_Z;
//import static com.fdkankan.push.PushMessageConfig.IOS_SECRET;
//import static com.fdkankan.push.PushMessageConfig.IOS_SECRET_Z;
//
//import cn.hutool.core.collection.CollUtil;
//import cn.hutool.core.date.DateUtil;
//import cn.hutool.core.exceptions.ExceptionUtil;
//import cn.hutool.core.util.StrUtil;
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.fdkankan.common.constant.BuildStatus;
//import com.fdkankan.common.constant.ConstantFilePath;
//import com.fdkankan.common.constant.ConstantUrl;
//import com.fdkankan.common.constant.ModelingBuildStatus;
//import com.fdkankan.common.constant.ServerCode;
//import com.fdkankan.common.constant.UploadFilePath;
//import com.fdkankan.common.exception.BusinessException;
//import com.fdkankan.common.util.ComputerUtil;
//import com.fdkankan.common.util.CreateObjUtil;
//import com.fdkankan.common.util.FileUtil;
//import com.fdkankan.common.util.FileUtils;
//import com.fdkankan.common.util.SceneUtil;
//import com.fdkankan.dingtalk.DingTalkSendUtils;
//import com.fdkankan.fyun.constant.StorageType;
//import com.fdkankan.fyun.oss.UploadToOssUtil;
//import com.fdkankan.modeling.bean.BuildSceneResultBean;
//import com.fdkankan.modeling.constants.SysConstants;
//import com.fdkankan.modeling.entity.BuildLog;
//import com.fdkankan.modeling.exception.BuildException;
//import com.fdkankan.modeling.service.IBuildLogService;
//import com.fdkankan.mq.message.BuildSceneFailDTMqMessage;
//import com.fdkankan.mq.message.BuildSceneMqMessage;
//import com.fdkankan.mq.message.BuildSceneResultMqMessage;
//import com.fdkankan.mq.util.RocketMQProducer;
//import com.fdkankan.push.PushMessageConfig;
//import com.fdkankan.push.PushMsgUtil;
//import com.fdkankan.redis.constant.RedisKey;
//import com.fdkankan.redis.util.RedisUtil;
//import com.taobao.api.ApiException;
//import java.io.File;
//import java.io.FileWriter;
//import java.io.IOException;
//import java.io.PrintWriter;
//import java.io.StringWriter;
//import java.io.UnsupportedEncodingException;
//import java.security.InvalidKeyException;
//import java.security.NoSuchAlgorithmException;
//import java.time.Duration;
//import java.time.temporal.ChronoUnit;
//import java.util.Date;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.Map.Entry;
//import java.util.Objects;
//import java.util.concurrent.Callable;
//import java.util.concurrent.CompletableFuture;
//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.Executors;
//import java.util.concurrent.Future;
//import java.util.concurrent.TimeUnit;
//import java.util.concurrent.TimeoutException;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.apache.commons.lang3.time.StopWatch;
//import org.apache.rocketmq.spring.annotation.MessageModel;
//import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
//import org.apache.rocketmq.spring.core.RocketMQListener;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.stereotype.Component;
//import org.springframework.util.ObjectUtils;
//import org.springframework.web.client.RestTemplate;
//
//
//@Slf4j
//@Component
//@RocketMQMessageListener(
//        consumerGroup = "${rocketmq.consumer.build-scene-group}",
//        topic = "${rocketmq.build-scene.topicName.topic-modeling-a}",
//        messageModel = MessageModel.CLUSTERING,//负载均衡模式
//        consumeThreadMax = 1,//消费者最大线程数，每次只消费一个
//        consumeTimeout = 172801000L
//)
//public class BuildSceneListener implements RocketMQListener<String> {
//
//    @Value("${rocketmq.consumer.build-scene-group}")
//    private String consumerGroup;
//
//    @Value("${rocketmq.build-scene.topicName.topic-modeling-a}")
//    private String topicName;
//
//    @Value("${rocketmq.build-scene.topicName.topic-modeling-a-dt}")
//    private String topicNameDt;
//
//    @Value("${rocketmq.build-scene-result.topicName.topic-modeling-a}")
//    private String buildSceneResultTopic;
//
//    @Autowired
//    RedisUtil redisUtil;
//
//    private RestTemplate restTemplate = new RestTemplate();
//
//    @Value("${4dkk.laserService.host}")
//    private String laserHost;
//
//    @Value("${upload.type}")
//    private String ossType;
//
//    @Value("${oss.prefix.ali}")
//    private String prefixAli;
//
//    @Autowired
//    private UploadToOssUtil uploadToOssUtil;
//
//    @Autowired
//    RocketMQProducer rocketMQProducer;
//
//    @Value("${environment:dev}")
//    private String environment;
//
//    @Autowired
//    private DingTalkSendUtils dingTalkSendUtils;
//
//    @Autowired
//    private IBuildLogService buildLogService;
//
//    @Override
//    public void onMessage(String message) {
//        log.info("开始处理消息，消费者组：{}，主题名：{}， 消息内容：{}", consumerGroup, topicName, message);
//        if (ObjectUtils.isEmpty(message)) {
//            SysConstants.SYSTEM_BUILDING = false;
//            log.error("消息体为空,退出构建,当前服务器id:{}", SysConstants.hostName);
//            return;
//        }
//        BuildSceneMqMessage buildSceneMqMessage = JSONObject.parseObject(message, BuildSceneMqMessage.class);
//        if(Objects.isNull(buildSceneMqMessage) || StrUtil.isBlank(buildSceneMqMessage.getSceneNum())){
//            log.error("消息内容错误，消费者组：{}，主题名：{}， 消息内容：{}", consumerGroup, topicName, message);
//            return;
//        }
//        process(buildSceneMqMessage);
//
//        log.info("处理消息结束，消费者组：{}，主题名：{}， 消息内容：{}", consumerGroup, topicName, message);
//    }
//
//    public void process(BuildSceneMqMessage message) {
//
//        SysConstants.SYSTEM_BUILDING = true;
//        if (SysConstants.SYSTEM_OFFING) {
//            SysConstants.SYSTEM_BUILDING = false;
//            log.error("服务实例：{} 正在关闭，退出构建！", SysConstants.hostName);
//            throw new BusinessException(ServerCode.SERVER_CLOSING);
//        }
//        //开始计时
//        StopWatch watch = new StopWatch();
//        watch.start();
//
//        BuildLog buildLog = new BuildLog();
//        final BuildSceneResultBean buildSceneResult = new BuildSceneResultBean();
//        Future<ModelingBuildStatus> future = null;
//        try {
//
//            //休眠2秒等待准备数据
//            Thread.sleep(2000L);
//
//            //计算前准备
//            preBuild(message, buildLog);
//
//            future = SysConstants.executorService.submit(()->{
//                return buildScene(message, buildSceneResult);
//            });
//            future.get(SysConstants.modelTimeOut, TimeUnit.HOURS);
//
//            //结束计时
//            watch.stop();
//            buildLog.setDuration(watch.getTime(TimeUnit.SECONDS));
//        } catch (TimeoutException ex) {
//            log.error("服务实例：{} 构建异常：",SysConstants.hostName,ex);
//            buildSceneResult.setBuildStatus(ModelingBuildStatus.OVERTIME);
//        } catch (BuildException e){
//            buildSceneResult.setBuildStatus(e.getBuildStatus());
//        } catch(Exception e) {
//            log.error("服务实例：{} 构建异常：", SysConstants.hostName, e);
//            if (e.getCause() instanceof BuildException) {
//                buildSceneResult.setBuildStatus(((BuildException) e.getCause()).getBuildStatus());
//            } else {
//                buildSceneResult.setBuildStatus(ModelingBuildStatus.FAILED);
//                //未知异常，记录异常信息
//                buildLog.setReason(ExceptionUtil.stacktraceToString(e, 3000));
//            }
//        }
//        //计算后处理
//        afterBuild(message, buildSceneResult, buildLog);
//
//    }
//
//    private ModelingBuildStatus buildScene(BuildSceneMqMessage message, BuildSceneResultBean buildSceneResult) throws Exception{
//        String projectNum = null;
//        Long computeTime = null;//计算耗时
//        //如果mq生产者在消息体中执行了计算结果mq的主题名，就发到这个主题名，否则就发送到配置的主题名
//        String resultTopicName = StrUtil.isNotBlank(message.getResultReceiverMqName()) ?
//                message.getResultReceiverMqName() : buildSceneResultTopic;
//        //该场景使用的容量
////        Long space = 0L;
//        //支付状态
//        int payStatus = 0;
//        String unicode = message.getUnicode();
//        String path = message.getPath();
//        String prefix = message.getPrefix();
//        projectNum = message.getSceneNum();
//        //不同的相机不同的方法
//        String cameraType = message.getCameraType();
//        String algorithm = message.getAlgorithm();
//        String fileId = message.getFileId();
//        String cameraName = message.getCameraName();
//        //0表示有4k图，1表示没有
//        String resolution = message.getResolution();
//        //判断调用V2还是V3版本的算法
//        String buildType = ObjectUtils.isEmpty(message.getBuildType()) ? "V2" : message.getBuildType();
//
//        String dataPath = "data/data" + projectNum;//老版本文件路径
//
//        Map<String,String> map = null;
//        Integer pushChannel = null;
//        String pushToken = null;
//        Integer videoVersion = null;
//
//        buildSceneResult.setResultTopicName(resultTopicName);
//        buildSceneResult.setCameraType(cameraType);
//        buildSceneResult.setNum(projectNum);
//
//
//        Map<String, String> dataMap = ComputerUtil.getTypeString(cameraType, algorithm,
//                resolution);
//        String splitType = dataMap.get("splitType");
//        String skyboxType = dataMap.get("skyboxType");
//        String dataDescribe = dataMap.get("dataDescribe");
//
//        log.info("用的算法是："+algorithm);
//        log.info("用的相机是："+ (Integer.parseInt(cameraType) < 4 ? "单球目" : "双球目（八目）"));
//
//        //4表示硬件部研发的双球目相机，其余为旧版本相机
//        if(Integer.parseInt(cameraType) < 3){
//
//            String data = FileUtils.readFile(path + File.separator + "capture" +File.separator+"data.fdage");
//            JSONObject dataJson = new JSONObject();
//            if(data!=null){
//                dataJson = JSONObject.parseObject(data);
//                if(dataJson.containsKey("imgs")){
//                    splitType = "SPLIT_V4";
//                }
//            }
//            //生成project.json和data.json供算法部使用
//            ComputerUtil.createJson(path, splitType, skyboxType, dataDescribe, projectNum, path);
//            //计算模型并返回需要上传oss的文件集合
//            map = ComputerUtil.computer(projectNum, path, buildType);
//
//        } else {
//
//            path = SceneUtil.getPath(path, cameraName, fileId, Integer.parseInt(cameraType), unicode);
//
//            String dataFdagePath = path + File.separator + "capture" +File.separator+"data.fdage";
//            log.info("dataFdagePath 文件路径 ：{}", dataFdagePath);
//            String data = FileUtils.readFile(dataFdagePath);
//            //获取data.fdage的内容
//            JSONObject dataJson = new JSONObject();
//            if(data!=null){
//                dataJson = JSONObject.parseObject(data);
//            }
//            pushChannel = dataJson.getInteger("pushChannel");
//            pushToken = dataJson.getString("pushToken");
//
//            /*
//             1、判断是否计算过资源，若计算过删除缓存, 如果caches中存在_images文件或者目录，就删除掉，否则就删除除了images以外的所有文件和目录
//             2、删除上一次计算出来的result目录
//             */
//            this.deleteCachesAndResult(path);
//
//            //v2版本使用4k算法
//            if(dataJson.containsKey("videoVersion")
//                    && StringUtils.isNotEmpty(dataJson.getString("videoVersion"))
//                    && Integer.parseInt(dataJson.getString("videoVersion")) < 4){
//                skyboxType = "SKYBOX_V6";
//            }
//
//            //生成project.json和data.json并写到path目录下供算法部使用
//            log.info("path:" + path);
//            ComputerUtil.createJson(path, splitType, skyboxType, dataDescribe, projectNum, path);
//            //计算模型并返回需要上传oss的文件集合
//            map = ComputerUtil.computer(projectNum, path, buildType);
//            //计算完成时间
//            log.info("计算完成耗时：{}",computeTime);
//
//            if(Integer.parseInt(cameraType) == 5 || Integer.parseInt(cameraType) == 6){
//                map.put(path + File.separator + "capture/stitch_params.txt", dataPath + "/stitch_params.txt");
//            }
//            map.put(path + File.separator + "capture/Up.xml", dataPath + "/Up.xml");
//            map.put(path + File.separator + "capture/Up2.xml", dataPath + "/Up2.xml");
//
//            //转台相机
//            if(Integer.parseInt(cameraType) == 13){
//                map.put(path + File.separator + "capture/Up.txt", dataPath + "/Up.txt");
//                map.put(path + File.separator + "capture/Up2.txt", dataPath + "/Up2.txt");
//            }
//
//            //计算已使用容量
//            payStatus = 1;
//
//            log.info("八目上完oss结束修改数据："+projectNum);
//
//            //读取计算结果文件生成videosJson
////                videosJson = this.getVideosJson(path, dataJson, projectNum, Integer.valueOf(cameraType));
//            String videoVersionStr = dataJson.getString("videoVersion");
//            videoVersion = StrUtil.isEmpty(videoVersionStr) ? null : Integer.parseInt(videoVersionStr);
//
//            //更新scene.json里面的video数据
////                this.updateVideosToSceneJson(projectNum, videosJson);
//
//            //计算成功  激光转台相机 同步 请求
//            this.jgSynch(message);
//        }
//
//        buildSceneResult.setBuildStatus(ModelingBuildStatus.SUCCESS);
//        buildSceneResult.setFileId(fileId);
//        buildSceneResult.setPayStatus(payStatus);
//        buildSceneResult.setUploadMap(map);
//        buildSceneResult.setPath(path);
//        buildSceneResult.setPushChannel(pushChannel);
//        buildSceneResult.setPushToken(pushToken);
//        buildSceneResult.setPrefix(prefix);
//        buildSceneResult.setVideoVersion(videoVersion);
//
//        CreateObjUtil.deleteFile(path.replace(ConstantFilePath.BUILD_MODEL_PATH, "/") + "/capture");
//
//        return ModelingBuildStatus.SUCCESS;
//
////        return BuildSceneResultBean.builder()
////            .buildStatus(ModelingBuildStatus.SUCCESS)
////            .resultTopicName(resultTopicName)
////            .cameraType(cameraType)
////            .fileId(fileId)
////            .payStatus(payStatus)
////            .num(projectNum)
////            .uploadMap(map)
////            .path(path)
////            .pushChannel(pushChannel)
////            .pushToken(pushToken)
////            .prefix(prefix)
////            .videoVersion(videoVersion)
////            .build();
//    }
//
//    private void afterBuild(BuildSceneMqMessage message, BuildSceneResultBean buildSceneResult, BuildLog buildLog){
//        try {
//            ModelingBuildStatus buildStatus = buildSceneResult.getBuildStatus();
//            String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, message.getSceneNum());
//            log.info("服务{} 计算结束:{},计算状态：{}", SysConstants.hostName, buildLog.getNum(),buildStatus.message());
//
//            if(!buildStatus.equals(ModelingBuildStatus.REPEAT)){
//                //释放锁
//                redisUtil.del(String.format(RedisKey.SCENE_BUILDING, message.getSceneNum()));
//
//                //生成status.json文件
//                this.upoadLog(message.getSceneStatus(), message.getWebSite(),
//                    message.getSceneNum(),message.getThumb(),message.getPayStatus(), message.getDataSource());
//
//                //如果是重复计算，没有走到计算逻辑，不需要上传日志文件
//                buildLog.setLogDetailPath(prefixAli+ buildLogPath + "console.log");
//            }
//            buildLog.setBuildStatus(buildStatus.code());
//            buildLog.setCameraType(Integer.parseInt(buildSceneResult.getCameraType()));
//            buildLogService.updateById(buildLog);
//
//        } catch (Exception e) {
//            log.error("计算后业务处理出错！", e);
//        }finally {
//            //发送计算结果mq
//            buildSceneResult.setDuration(buildLog.getDuration());
//            this.sendCallResult(message, buildSceneResult);
//
//            //计算完毕，将当前系统构建状态改为false
//            SysConstants.SYSTEM_BUILDING = false;
//        }
//    }
//
//    private void uploadCaches(String num, Map<String,String> map, String path){
//
//        String sceneNumPAth = String.format("scene/%s", num);
//
//        List<String> imagesList = FileUtil.getFileList(path + "/caches/images");
//        log.info("caches/images_path:{}", path + "/caches/images");
//        if(CollUtil.isNotEmpty(imagesList)){
//            log.info("上传的caches/images文件列表：{}", imagesList.toString());
//            imagesList.stream().forEach(str -> map.put(str, str.replace(path, sceneNumPAth)));
//        }
//
//        List<String> videosList = FileUtil.getFileList(path + "/caches/videos");
//        if(CollUtil.isNotEmpty(videosList)){
//            log.info("上传的caches/videos文件列表：{}", videosList.toString());
//            videosList.stream().forEach(str -> map.put(str, str.replace(path, sceneNumPAth)));
//        }
//
//    }
//
//    private void preBuild(BuildSceneMqMessage message, BuildLog buildLog) throws BuildException {
//
//        // 初始化日志参数
//        buildLog.setHostName(SysConstants.hostName);
//        buildLog.setTopicName(topicName);
//        buildLog.setNum(message.getSceneNum());
//        buildLog.setDataSource(message.getDataSource());
//        buildLogService.save(buildLog);
//
////        String key = RedisKey.SCENE_BUILDING + message.getSceneNum();
////        Long building = redisUtil.incr(key, 1);
////        if (building.compareTo(1L) != 0) {
////            log.error("场景正在构建中,退出构建,当前服务器id:{},参数：{}", SysConstants.hostName, JSONObject.toJSONString(message));
////            throw new BuildException(ModelingBuildStatus.REPEAT);
////        } else {
////            redisUtil.expire(key, Duration.of(SysConstants.modelTimeOut, ChronoUnit.HOURS));
////        }
//    }
//
//    private void copyToEditDir(String num) throws IOException {
//
//        String editImagesPath = String.format(UploadFilePath.IMG_EDIT_PATH, num);
//        String viewImagesPath = String.format(UploadFilePath.IMG_VIEW_PATH, num);
//
//        String editDataPath = String.format(UploadFilePath.DATA_EDIT_PATH, num);
//        String viewDataPath = String.format(UploadFilePath.DATA_VIEW_PATH, num);
//
//        Map<String, String> map = new HashMap<>();
//        map.put(editImagesPath + "vision.modeldata", viewImagesPath + "vision.modeldata");
//        map.put(editImagesPath + "vision2.modeldata", viewImagesPath + "vision2.modeldata");
//        map.put(editDataPath + "floorplan_cad.json", viewDataPath + "floorplan_cad.json");
//
//        for (Entry<String, String> entry : map.entrySet()) {
//            uploadToOssUtil.copyFiles(entry.getValue(), entry.getKey());
//        }
//    }
//
//    /**
//     * 发送计算结果
//     * @param message
//     * @param buildSceneResult
//     */
//    private void sendCallResult(BuildSceneMqMessage message, BuildSceneResultBean buildSceneResult){
//        ModelingBuildStatus buildStatus = buildSceneResult.getBuildStatus();
//        //重复计算不需要发送mq做后置处理
//        if(buildStatus.equals(ModelingBuildStatus.REPEAT)){
//            return;
//        }
//        boolean buildSuccess = buildStatus.equals(ModelingBuildStatus.SUCCESS) ? true : false;
//        rocketMQProducer.sendOneWay(buildSceneResult.getResultTopicName(),
//                BuildSceneResultMqMessage.builder()
//                    .buildSuccess(buildSuccess)
//                    .cameraType(buildSceneResult.getCameraType())
//                    .computeTime(buildSceneResult.getDuration())
//                    .fileId(buildSceneResult.getFileId())
//                    .payStatus(buildSceneResult.getPayStatus())
//                    .sceneCode(message.getSceneNum())
//                    .uploadFiles(buildSceneResult.getUploadMap())
//                    .path(buildSceneResult.getPath())
//                    .pushChannel(buildSceneResult.getPushChannel())
//                    .pushToken(buildSceneResult.getPushToken())
//                    .prefix(buildSceneResult.getPrefix())
//                    .videoVersion(buildSceneResult.getVideoVersion())
//                    .build());
//
//        //如果是计算失败，需要发送钉钉
//        if(!buildSuccess){
//            // TODO: 2022/1/25 测试阶段，先注释掉推送
//            this.sendDingTalkMq(buildStatus.message(), message);
//        }
//    }
//
//    private void upoadLog(Integer sceneStatus, String webSite,
//            String num, String thumb, Integer payStatus, String dataSource){
//        try{
//            JSONObject statusJson = new JSONObject();
//            //临时将-2改成1，app还没完全更新
//            if(sceneStatus == -2){
//                sceneStatus = 1;
//            }else if(sceneStatus == -1){
//                // 失败状态不予显示到客户端
//                sceneStatus = 0;
//            }
//            statusJson.put("status", sceneStatus);
//            statusJson.put("webSite", webSite);
//            statusJson.put("sceneNum", num);
//            statusJson.put("thumb", thumb);
//            statusJson.put("payStatus", payStatus);
//            FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data/data"+num+File.separator+"status.json", statusJson.toString());
//
//            String dataPath = String.format(UploadFilePath.DATA_VIEW_PATH, num);
//            String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, num);
//
//            //todo 待删除old_path
//            uploadToOssUtil.upload(
//                ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
//                "data/data" + num + File.separator + "status.json");
//
//            uploadToOssUtil.upload(
//                ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
//                dataPath + "status.json");
//
//            uploadToOssUtil.upload(dataSource + File.separator + "console.log",
//                buildLogPath + "console.log");
//
//        }catch (Exception e){
//            log.error("上传日志失败！", e);
//        }
//    }
//
//    private void jgSynch(BuildSceneMqMessage message){
//        log.info("激光转台相机 同步 请求 ");
//        if(Integer.parseInt(message.getCameraType()) != 14)
//            return;
//
//        String sceneName = message.getSceneName();
//        String dataSource = message.getDataSource();
//        Long userId = message.getUserId();
//        String userName = message.getUserName();
//        String cameraName = message.getCameraName();
//        try {
//            String title = "";
//            if(StringUtils.isNotEmpty(sceneName)){
//                title = sceneName;
//            }
////                        String dataSource = sceneProExt.getDataSource();
//            String jgPath = dataSource;
//            //创建目录
//            if(dataSource.lastIndexOf("/")!=-1){
//                jgPath = jgPath + "_laserData";
//            }else{
//                jgPath = jgPath.substring(0,jgPath.length()-1) + "_laserData";
//            }
//
//            FileUtils.createDir(jgPath+"/extras");
//
//            log.info("生成 激光相机目录 " + jgPath);
//            //生成data.json
//            JSONObject jgDataJson = new JSONObject();
//            jgDataJson.put("split_type", "SPLIT_V15");
//            jgDataJson.put("skybox_type", "SKYBOX_V5");
//            jgDataJson.put("extras", null);
//            FileUtils.writeFile(jgPath + File.separator + "data.json", jgDataJson.toString());
//
//            CreateObjUtil.cpfile(dataSource  + "/results/laserData/cover", jgPath+"/extras/");
//            CreateObjUtil.cplaserfile(dataSource  + "/results/laserData", jgPath+File.separator);
//
//            //激光相机
//            String url = laserHost+"/indoor/{sceneCode}/service/init?path="
//                    + jgPath + File.separator + "laserData" + "&title="+ title
//                    + "&childName=" + cameraName + "&createTime=" +  message.getSceneProCreateTime()
//                    + "&snCode="+ cameraName;
//
//            if(userId!=null){
//                url = url + "&userId=" + userId;
//            }
//
//            if(StringUtils.isNotEmpty(userName)){
//                url = url + "&phone=" + userName;
//            }
//
//            url = url.replace("{sceneCode}",message.getSceneNum());
//            log.info("激光转台相机 同步 ：" + url);
//            JSONObject hotListJson =
//                    JSONObject.parseObject(restTemplate.getForObject(url,String.class));
//            log.info("激光转台相机 同步结束 ：" + hotListJson);
//        }catch (Exception e){
//            log.error("激光转台相机同步失败", e);
//            // TODO: 2022/1/25 测试阶段，先注释掉推送
////            this.sendDingTalkMq("激光转台相机同步失败", message);
//        }
//    }
//
//    private void sendSms(JSONObject dataJson, int cameraType, String sceneName, String webSite){
//        log.info("推送消息，渠道是 {}, 手机token是 {}", dataJson.get("pushChannel"), dataJson.get("pushToken"));
//        if(dataJson.containsKey("pushChannel") && dataJson.containsKey("pushToken")){
//            try{
//                if(StorageType.AWS.code().equals(ossType)){
//                    PushMsgUtil.googlePushMsg(ConstantFilePath.BASE_PATH + "/refreshToken.json",dataJson.getString("pushToken"),
//                            sceneName + "计算完成", "您上传的" + sceneName + "计算完成，点击查看",
//                            webSite);
//                    return;
//                }
//
//                PushMessageConfig demo = null;
//                if(dataJson.getIntValue("pushChannel") == 0){
//
//                    if(cameraType == 10 || cameraType == 13){
//                        //ios
//                        log.info("IOS_KEY:{}, IOS_SECRET:{}", IOS_KEY_Z, IOS_SECRET_Z);
//                        demo = new PushMessageConfig(IOS_KEY_Z, IOS_SECRET_Z);
//                        demo.sendIOSUnicast(dataJson.getString("pushToken"),
//                                "四维看看Minion", sceneName + "计算完成", "您上传的" + sceneName + "计算完成，点击查看",
//                                webSite);
//                    }else {
//                        //ios
//                        log.info("IOS_KEY:{}, IOS_SECRET:{}", IOS_KEY, IOS_SECRET);
//                        demo = new PushMessageConfig(IOS_KEY, IOS_SECRET);
//                        demo.sendIOSUnicast(dataJson.getString("pushToken"),
//                                "四维看看Pro", sceneName + "计算完成", "您上传的" + sceneName + "计算完成，点击查看",
//                                webSite);
//                    }
//
//                }else {
//                    if(cameraType == 10 || cameraType == 13){
//                        //ios
//                        //安卓
//                        log.info("ANDROID_KEY:{}, ANDROID_SECRET:{}", ANDROID_KEY_Z, ANDROID_SECRET_Z);
//                        demo = new PushMessageConfig(ANDROID_KEY_Z, ANDROID_SECRET_Z);
//                        demo.sendAndroidUnicast2(dataJson.getString("pushToken"),
//                                "四维看看Minion", sceneName + "计算完成", "您上传的" + sceneName + "计算完成，点击查看",
//                                webSite);
//                    }else {
//                        //安卓
//                        log.info("ANDROID_KEY:{}, ANDROID_SECRET:{}", ANDROID_KEY, ANDROID_SECRET);
//                        demo = new PushMessageConfig(ANDROID_KEY, ANDROID_SECRET);
//                        demo.sendAndroidUnicast(dataJson.getString("pushToken"),
//                                "四维看看Pro", sceneName + "计算完成", "您上传的" + sceneName + "计算完成，点击查看",
//                                webSite);
//                    }
//                }
//                log.info("消息推送结束！");
//            }catch (Exception e){
//                log.error("推送消息失败：", e);
//            }
//        }
//    }
//
//    private void updateVideosToSceneJson(String projectNum, JSONObject videosJson) throws Exception {
//        String sceneJsonPath = String.format(ConstantFilePath.SCENE_PATH_FORMAT, projectNum);
//        String strsceneInfos = FileUtils.readFile(sceneJsonPath);
//        JSONObject scenejson = new JSONObject();
//        if(strsceneInfos!=null){
//            scenejson = JSONObject.parseObject(strsceneInfos);
//        }
//        scenejson.put("videos", videosJson.toJSONString());
//        FileUtils.writeFile(sceneJsonPath, scenejson.toString());
//    }
//
//    private JSONObject getVideosJson(String path, JSONObject dataJson, String projectNum, int cameraType) throws Exception {
//        //读取videos_hdr_param.json, 保存点位视频的value
//        Map<String, Object> videoMap = new HashMap<>();
//        String videosHdr = FileUtils.readFile(path + File.separator + "results/videos/videos_hdr_param.json");
//        JSONArray videoArray = null;
//        if(StringUtils.isNotEmpty(videosHdr)){
//            videoArray = JSONObject.parseObject(videosHdr).getJSONArray("hdr_param");
//        }
//        if(videoArray != null){
//            for(int i = 0, len = videoArray.size(); i < len; i++) {
//                videoMap.put(videoArray.getJSONObject(i).getString("name"), videoArray.getJSONObject(i).getString("value"));
//                if(videoArray.getJSONObject(i).containsKey("fov")){
//                    videoMap.put(videoArray.getJSONObject(i).getString("name") + "_fov", videoArray.getJSONObject(i).getString("fov"));
//                }
//            }
//        }
//
//        //获取upload中的video视频名称
//        String uploadData = FileUtils.readFile(path + File.separator + "results" +File.separator+"upload.json");
//        JSONObject uploadJson = null;
//        JSONArray array = null;
//        if(uploadData!=null) {
//            uploadJson = JSONObject.parseObject(uploadData);
//            array = uploadJson.getJSONArray("upload");
//        }
//        JSONObject fileJson = null;
//        String fileName = "";
//
//        //计算ts文件的大小，并拼接成json格式
//        JSONArray jsonArray = new JSONArray();
//        JSONObject videoJson = null;
//        JSONObject videosJson = new JSONObject();
//        long videoSize = 0L;
//        for(int i = 0, len = array.size(); i < len; i++) {
//            fileJson = array.getJSONObject(i);
//            fileName = fileJson.getString("file");
//            if(fileJson.getIntValue("clazz") == 11 && fileName.contains(".mp4") && !fileName.contains("-ios.mp4")){
//                videoJson = new JSONObject();
//                videoJson.put("id", fileName.substring(
//                        0, fileName.lastIndexOf(".")).replace("videos/", ""));
//
//                //如果ts文件存在，就计算ts大小
//                if(new File(path + File.separator + "results" +File.separator+ fileName.replace(".mp4", ".ts")).exists()){
//                    videoSize = new File(path + File.separator + "results" +File.separator+ fileName.replace(".mp4", ".ts")).length();
//                    videoJson.put("tsSize", videoSize);
//                }
//                if(videoMap.containsKey(videoJson.get("id"))){
//                    videoJson.put("value", videoMap.get(videoJson.get("id")));
//                }
//                if(videoMap.containsKey(videoJson.get("id") + "_fov")){
//                    videoJson.put("blend_fov", videoMap.get(videoJson.get("id") + "_fov"));
//                }else {
//                    videoJson.put("blend_fov", 7);
//                }
//                jsonArray.add(videoJson);
//            }
//        }
//
//        videosJson.put("data", jsonArray);
//        if(dataJson.containsKey("videoVersion") && StringUtils.isNotEmpty(dataJson.getString("videoVersion")) && Integer.parseInt(dataJson.getString("videoVersion")) >= 4){
//            videosJson.put("version", 3);
//            if(StorageType.OSS.code().equals(ossType)){
//                videosJson.put("upPath", prefixAli + "data/data" + projectNum + "/Up.xml");
//            }
//            if(StorageType.AWS.code().equals(ossType)){
//                videosJson.put("upPath", ConstantUrl.PREFIX_AWS + "data/data" + projectNum + "/Up.xml");
//            }
//            if(cameraType == 13){
//                //转台相机
//                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
//            }
//        }else {
//            videosJson.put("version", 1);
//            if("oss".equals(ossType)){
//                videosJson.put("upPath", prefixAli + "data/data" + projectNum + "/Up2.xml");
//            }
//            if("aws".equals(ossType)){
//                videosJson.put("upPath", ConstantUrl.PREFIX_AWS + "data/data" + projectNum + "/Up2.xml");
//            }
//
//            if(cameraType == 13){
//                //转台相机
//                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
//            }
//        }
//
//        if(cameraType == 5 || cameraType == 6){
//            videosJson.put("version", 1);
//            if("oss".equals(ossType)){
//                videosJson.put("upPath", prefixAli + "data/data" + projectNum + "/stitch_params.txt");
//            }
//            if("aws".equals(ossType)){
//                videosJson.put("upPath", ConstantUrl.PREFIX_AWS + "data/data" + projectNum + "/stitch_params.txt");
//            }
//        }
//
//        return videosJson;
//    }
//
//    private String downLoadSource(String path, int cameraType, String cameraName, String unicode, String fileId, String imgsName, String prefix) throws Exception {
//        if(cameraType < 4){
//            throw new Exception("cameraType 不能小于4");
//        }
//        //cameraType=5为新版本双目, cameraType=6为小红屋新版本双目
//        String ossPath = ConstantFilePath.OSS_PREFIX + cameraName.replace("4DKKPRO_", "")
//                .replace("-fdage", "").toLowerCase() + File.separator + fileId + File.separator
//                + unicode + File.separator;
//        String localPath = cameraName.replace("4DKKPRO_", "").replace("-fdage", "").toLowerCase() +
//                File.separator + fileId + File.separator + unicode;
//        if(cameraType == 5 || cameraType == 6){
//            path = ConstantFilePath.BUILD_MODEL_PATH + unicode;
//            //下载zip包
//            FileUtils.downLoadFromUrl(prefix + "/" + imgsName + "?m=" + System.currentTimeMillis(), imgsName, path + File.separator + "capture");
//            //解压
//            FileUtils.decompress(path + File.separator + "capture" + File.separator + imgsName,
//                    path + File.separator + "capture") ;
//            //删除压缩包
//            FileUtil.delFile(path + File.separator + "capture" + File.separator + imgsName);
//        }else if(cameraType == 14) {
////                    + File.separator + "capture"
//            path = ConstantFilePath.BUILD_MODEL_LASER_PATH + localPath;
//            CreateObjUtil.ossUtilCp(ossPath,path + File.separator + "capture");
//        } else{
//            path = ConstantFilePath.BUILD_MODEL_PATH + localPath;
//            CreateObjUtil.ossUtilCp(ossPath,path + File.separator + "capture");
//        }
//        return path;
//    }
//
//    private void deleteCachesAndResult(String path){
//        //判断是否计算过资源，若计算过删除缓存, 如果caches中存在_images文件或者目录，就删除掉，否则就删除除了images以外的所有文件和目录
//        File caches = new File(path + File.separator + "caches");
//        if(caches.exists()){
//            for(File deleteFile : caches.listFiles()){
//                if(new File(path + "_images").exists()){
//                    if(deleteFile.isDirectory()){
//                        FileUtils.delAllFile(deleteFile.getAbsolutePath());
//                    }else {
//                        FileUtils.deleteFile(deleteFile.getAbsolutePath());
//                    }
//                }else if(!deleteFile.getAbsolutePath().contains("images")){
//                    if(deleteFile.isDirectory()){
//                        FileUtils.delAllFile(deleteFile.getAbsolutePath());
//                    }else {
//                        FileUtils.deleteFile(deleteFile.getAbsolutePath());
//                    }
//                }
//            }
//        }
//        //删除上一次计算出来的result目录
//        if(new File(path + File.separator + "results").exists()){
//            FileUtils.delAllFile(path + File.separator + "results");
//        }
//    }
//
//    private void sendDingTalkMq(String reason,BuildSceneMqMessage message){
//        String serverPath = message.getPath().substring(0,message.getPath().lastIndexOf("/")+1).concat(message.getPrefix());
//        rocketMQProducer.sendOneWay(topicNameDt,
//            BuildSceneFailDTMqMessage.builder()
//                .hostName(SysConstants.hostName)
//                .reason(reason)
//                .num(message.getSceneNum())
//                .serverPath(serverPath)
//                .build());
//    }
//
//    private void handFail(String reason,BuildSceneMqMessage message){
//        String serverPath = message.getPath().substring(0,message.getPath().lastIndexOf("/")+1).concat(message.getPrefix());
//        handFail(reason,serverPath,message.getSceneNum());
//    }
//
//    private void handFail(String reason,String serverPath,String num){
//        CompletableFuture.runAsync(() -> {
//            try {
//                String content = String.format(SysConstants.DINGTALK_MSG_PATTERN,environment, SysConstants.hostName,reason,num,serverPath,num,num);
//                dingTalkSendUtils.sendActioncardMsgToDingRobot(content,"场景计算失败");
//            } catch (ApiException | UnsupportedEncodingException | NoSuchAlgorithmException | InvalidKeyException apiException) {
//                apiException.printStackTrace();
//            }
//        });
//    }
//}
