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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.qrcode.QrCodeUtil;
import cn.hutool.extra.qrcode.QrConfig;
import cn.hutool.http.ContentType;
import cn.hutool.http.HttpUtil;
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.DateUtil;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.contro.bean.SyncLaserResultBean;
import com.fdkankan.contro.constant.UserEditDataType;
import com.fdkankan.contro.entity.*;
import com.fdkankan.contro.mq.service.IBuildSceneService;
import com.fdkankan.contro.service.*;
import com.fdkankan.contro.util.HttpUtilExt;
import com.fdkankan.fyun.config.FYunFileConfig;
import com.fdkankan.fyun.constant.FYunTypeEnum;
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.CreateHouseJsonUtil;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.model.utils.SceneUtil;
import com.fdkankan.push.config.PushMessageConfig;
import com.fdkankan.push.utils.PushMsgUtil;
import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
import com.fdkankan.rabbitmq.bean.BuildSceneResultMqMessage;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import com.fdkankan.redis.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpHeaders;
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.io.IOException;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;


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

    @Value("${queue.modeling.modeling-call}")
    private String queueModelingCall;

    @Value("${queue.modeling.single.modeling-call}")
    private String singleModelingCall;

    @Value("${model.type:#{null}}")
    private String modelType;

    @Value("${model.modelKind:3dtiles}")
    private String modelKind;

    @Value("#{'${model.3dtiles.sceneSource:}'.split(',')}")
    private List<Integer> sdTilesSceneSourceList;

    @Value("${env:gn}")
    private String env;

    @Value("#{'${build.scene.post.not-delete-nas-nums:}'.split(',')}")
    private List<String> notDeleteNasNumList;

    @Value("4dkk.laserService.bucket")
    private String laserBucket;

    @Autowired
    private RabbitMqProducer mqProducer;

    @Resource
    private FYunFileServiceInterface fYunFileService;
    @Autowired
    private ICameraDetailService cameraDetailService;
    @Autowired
    private ISceneEditInfoService sceneEditInfoService;
    @Autowired
    private ISceneEditControlsService sceneEditControlsService;

    @Autowired
    private FYunFileConfig fYunFileConfig;

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private IScenePlusExtService scenePlusExtService;
    @Autowired
    private ISceneEditInfoExtService sceneEditInfoExtService;

    @Autowired
    private IUserIncrementService userIncrementService;

    @Autowired
    private IFdkkLaserService fdkkLaserService;


//    @Autowired
//    private IBuildSceneDTService buildSceneDTService;


    @Autowired
    private IIncrementTypeService incrementTypeService;

    @Autowired
    private ICompanyService companyService;
    @Autowired
    private ISceneAsynOperLogService sceneAsynOperLogService;
    @Autowired
    private ICommonService commonService;
    @Autowired
    private ISceneBuildProcessLogService sceneBuildProcessLogService;
    @Autowired
    private ISceneColdStorageService sceneColdStorageService;
    @Autowired
    private IOrigFileUploadBatchService origFileUploadBatchService;
    @Autowired
    private IOrigFileUploadService origFileUploadService;
    @Autowired
    private ILinkPanService linkPanService;
    @Autowired
    private IJmgaService jmgaService;


    @Override
    public void buildScenePre(BuildSceneCallMessage message) throws Exception{
        boolean success = false;
        String num = message.getSceneNum();
        String batchIds = (String) message.getExt().get("batchId");
        String threeCamType = (String) message.getExt().get("threeCamType");
        try {

            //如果场景原始资源上传批次id不为空，则需要下载批次文件上传到oss目录
            if(StrUtil.isNotEmpty(batchIds)){
                for (String batchId : batchIds.split(",")) {
                    if(StrUtil.isNotEmpty(threeCamType) && "yzl".equals(threeCamType)){
                        this.downloadOrigFile4Yzl(batchId, message.getPath());
                    }else{
                        this.downloadOrigFile(batchId, message.getPath());
                    }
                }
            }


            //重新计算时需要删除文件夹，否知使用缓存
            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");
            }

            //删除project.json文件
            FileUtil.del(message.getPath().concat(File.separator).concat("project.json"));

            //删除点位校准数据
            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);
                }
                FileUtil.del(message.getPath() + "/extras");
            }

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

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

            //校验文件是否完整
            jmgaService.checkFileWhole(uuid, dataSource, fdageData);

            List<String> linkPanTargetList = linkPanService.genLinkPanPre(num);
            if(CollUtil.isNotEmpty(linkPanTargetList)){
                Map<String, Object> ext = message.getExt();
                if(Objects.isNull(ext)){
                    ext = new HashMap<>();
                    message.setExt(ext);
                }
                ext.put("linkPanTargetList", linkPanTargetList);
            }

            JSONObject fdageJson = JSONObject.parseObject(FileUtils.readFile(message.getPath().concat("/capture/data.fdage")));

            boolean rewrite = false;
            // 兼容旧的数据，防止OnlyExportMeshObj标志未删除掉
            if (fdageJson.containsKey("OnlyExportMeshObj")) {
                log.info("data.fdage 包含 OnlyExportMeshObj,进行去除!");
                // 写入data.fdage 防止重算
                fdageJson.remove("OnlyExportMeshObj");
                String ossPath = getOssPath(message.getPath());
                fYunFileService.uploadFile(fdageJson.toJSONString().getBytes(), ossPath + "data.fdage");
                rewrite = true;
            }

            if (!ObjectUtils.isEmpty(modelType)) {
                // 修改dataFdage文件
                fdageJson.put("modelType", modelType);
                rewrite = true;
            }

            if (rewrite) {
                FileUtils.writeFile(message.getPath().concat("/capture/data.fdage"), fdageJson.toJSONString());
            }

            message.getBuildContext().put("cameraType",message.getCameraType());

            //查询是否超过比例50%，如果超过，则启动128G服务器弹性伸缩
            Float maxRate = fdageJson.getFloat("maxRate");
            if(env.equals("gn") && Objects.nonNull(maxRate) && maxRate > 50){
                Map<String, Object> ext = message.getExt();
                if(Objects.isNull(ext)){
                    ext = new HashMap<>();
                    message.setExt(ext);
                }
                ext.put("128G", 1);
            }

            Map<String, Object> param = new HashMap<>();
            try {
                param.put("event_type", "排队中");
                param.put("event_content", "排队中");
                param.put("scene_num", num);
                param.put("event_time", new Date());
                param.put("ryid", scenePlusService.getRyIdByNum(num));
                jmgaService.sendStatus(param);
            }catch (Exception e){
                log.info("推送事件失败,param:{}", param);
            }

            mqProducer.sendByWorkQueue(queueModelingCall, message);

            if(StrUtil.isNotEmpty(batchIds)){
                origFileUploadBatchService.update(new LambdaUpdateWrapper<OrigFileUploadBatch>().set(OrigFileUploadBatch::getStatus, 1).in(OrigFileUploadBatch::getBatchId, batchIds.split(",")));
            }

            log.info("场景计算资源准备结束，场景码：{}", message.getSceneNum());

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

            scenePlusService.update(new LambdaUpdateWrapper<ScenePlus>()
                    .set(ScenePlus::getSceneStatus, SceneStatus.FAILD.code())
                    .eq(ScenePlus::getNum, num));

            this.sendFailToLaser(num);

            Map<String, Object> param = new HashMap<>();
            try {
                param.put("event_type", "计算失败");
                param.put("event_content", "计算资源准备失败");
                param.put("scene_num", num);
                param.put("event_time", new Date());
                param.put("ryid", scenePlusService.getRyIdByNum(num));
                jmgaService.sendStatus(param);
            }catch (Exception ex){
                log.info("推送事件失败,param:{}", param);
            }

            throw e;
        }
    }

    private void downloadOrigFile(String batchId, String dataSource){
        if(StrUtil.isEmpty(batchId)){
            return;
        }

        List<OrigFileUpload> fileList = origFileUploadService.getByBatchId(batchId);
        if(CollUtil.isEmpty(fileList)){
            return;
        }
        String homePath = "/oss/4dkankan/" + SceneUtil.getHomePath(dataSource);


        for (OrigFileUpload origFileUpload : fileList) {
            int times = 0;
            String filePath = homePath.concat(origFileUpload.getFileName());
            do{
                try {
                    ++times;
                    HttpUtil.downloadFile(origFileUpload.getFileUrl(), new File(filePath), 10 * 60 * 1000);
                    if(FileUtil.exist(filePath)){
                        break;
                    }
                }catch (Exception e){
                    log.info("原始文件第{}次下载失败，fileUrl:{}, filePath:{}", origFileUpload.getFileUrl(), filePath);
                }
            }while (times < 4);

            if(!FileUtil.exist(filePath)){
                throw new RuntimeException("原始文件下载失败，fileUrl:" + origFileUpload.getFileUrl() + ", filePath:" + filePath);
            }
        }
    }

    private void downloadOrigFile4Yzl(String batchId, String dataSource){
        if(StrUtil.isEmpty(batchId)){
            return;
        }

        OrigFileUpload sceneUpData = origFileUploadService.getByBatchIdAndFileName(batchId, "scene_up_data.txt");
        String sceneUpDataPath = dataSource + "/" + "scene_up_data.txt";
        HttpUtilExt.downloadFileAndCheck(sceneUpData.getFileUrl(), sceneUpDataPath, 60000);
        String sceneUpDataStr = FileUtil.readUtf8String(sceneUpDataPath);
        JSONArray fileJsonArray = JSON.parseArray(sceneUpDataStr);
        Map<String, String> fileMap = fileJsonArray.stream().collect(Collectors.toMap(v -> ((JSONObject) v).getString("fileName"), v -> ((JSONObject) v).getString("filePath")));

        List<OrigFileUpload> fileList = origFileUploadService.getByBatchId(batchId);
        if(CollUtil.isEmpty(fileList)){
            return;
        }
        String homePath = "/oss/4dkankan/" + SceneUtil.getHomePath(dataSource);


        for (OrigFileUpload origFileUpload : fileList) {
            String relativeFilePath = fileMap.get(origFileUpload.getFileName());
            if(StrUtil.isEmpty(relativeFilePath)){
                continue;
            }
            int times = 0;
            String filePath = homePath.concat(relativeFilePath);
            do{
                try {
                    ++times;
                    HttpUtil.downloadFile(origFileUpload.getFileUrl(), new File(filePath), 10 * 60 * 1000);
                    if(FileUtil.exist(filePath)){
                        break;
                    }
                }catch (Exception e){
                    log.info("原始文件第{}次下载失败，fileUrl:{}, filePath:{}", origFileUpload.getFileUrl(), filePath);
                }
            }while (times < 4);

            if(!FileUtil.exist(filePath)){
                throw new RuntimeException("原始文件下载失败，fileUrl:" + origFileUpload.getFileUrl() + ", filePath:" + filePath);
            }
        }
    }

    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();
        String batchIds = (String) message.getExt().get("batchId");
        Long count = redisUtil.decr("modeling-count:" + sceneCode, 1);
        log.info("场景:{},剩余计算次数：{}", sceneCode, count);
        try {

            //如果场景被删除，就无需往下运行了
            ScenePlus scenePlusByNum = scenePlusService.getScenePlusByNum(sceneCode);
            if(Objects.isNull(scenePlusByNum)){
                log.info("场景已被删除,场景码:{}", sceneCode);
                return;
            }

            // 上传计算日志
            //如果是重复计算，没有走到计算逻辑，不需要上传日志文件
            log.info("开始上传计算日志");
            String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, sceneCode);
            fYunFileService.uploadFile(path + File.separator + "console.log", buildLogPath + "console.log");
            log.info("计算日志上传完成");

            JSONObject fdageData = getFdageData(path + File.separator + "capture" +File.separator+"data.fdage");
            String uuid = fdageData.getString("creator") + "_" + fdageData.getString("uuidtime");


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

                    this.sendFailToLaser(sceneCode);

                    Map<String, Object> param = new HashMap<>();
                    try {
                        param.put("event_type", "计算失败");
                        param.put("event_content", "算法报错");
                        param.put("scene_num", sceneCode);
                        param.put("event_time", new Date());
                        param.put("ryid", scenePlusService.getRyIdByNum(sceneCode));
                        jmgaService.sendStatus(param);
                    }catch (Exception e){
                        log.info("推送事件失败,param:{}", param);
                    }
                }
//                redisUtil.set(String.format(RedisKey.SCENE_BUILD_FINISH_NUM, sceneCode), "-1");
                return;
            }

            ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneCode);

            Integer cameraType = Integer.parseInt(message.getBuildContext().get("cameraType").toString());
            Map<String, String> uploadFiles = getUploadFiles(scenePlus,path,cameraType,fdageData);

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

            Integer videoVersion = fdageData.getInteger("videoVersion");
            //读取计算结果文件生成videosJson
            JSONObject videosJson = this.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);

            Integer hasAi = this.uploadFreespace(sceneCode, path, uploadFiles);
            scenePlus.setHasAi(hasAi);

            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);

            //修改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());

            //生成场景关联数据
            Integer links = linkPanService.genLinkPanPost(sceneCode);

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

            //江门需求，算法识别平面图
            commonService.uploadFloorplanAi(sceneCode, path);

            LinkedHashMap<Integer, Boolean> detFloorplan = message.getDetFloorplan();
            boolean hasFloorplanAi = commonService.detFloorPlanAi(sceneCode, path, detFloorplan);
            if(hasFloorplanAi){
                scenePlus.setHasFloorplanAi(CommonStatus.YES.code().intValue());
            }else{
                scenePlus.setHasFloorplanAi(CommonStatus.NO.code().intValue());
            }

            //重置异步操作记录
            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);

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

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

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

            scenePlusExt.setOrientation(fdageData.getString("orientation"));

            if (cameraType == 14) {
                //计算成功  激光转台相机 同步 请求
                fdkkLaserService.syncBuildResult(
                        SyncLaserResultBean.builder()
                        .num(sceneCode).dataSource(path)
                        .sceneStatus(2)
                        .createTime(scenePlus.getCreateTime())
                        .shootCount(scenePlusExt.getShootCount())
                        .payStatus(scenePlus.getPayStatus())
                        .mixture(scenePlusExt.getMixture())
                        .version(SceneVersionType.V4.code()).build());
                sceneEditControlsService.update(new LambdaUpdateWrapper<SceneEditControls>().set(SceneEditControls::getShowMap,0)
                        .eq(SceneEditControls::getEditInfoId,sceneEditInfo.getId()));
                sceneEditControls.setShowMap(0);
            } else if (new File(path + "/results/laserData/vision_edit.txt").exists()) {
                fdkkLaserService.cloudPointBuild(sceneCode,path);
            }


            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, videosJson,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, "/"));
//            }

            //更新场景主表
            //如果相机容量不足，需要把场景的paystatus改为容量不足状态
            if (cameraType != 14) {
                scenePlus.setPayStatus(commonService.getPayStatus(scenePlus.getCameraId(), space));
            }

            this.uploadStatusJson(scenePlus, scenePlusExt);

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

            //国际环境需要发邮件通知
            if("eur".equals(env)){
                commonService.sendEmail(sceneCode);
            }

            //拜城公安需求
//            this.sendMqForBcgn(sceneCode);

            //推送ai识别平面图mq
            this.sendMqForAiPano(sceneCode);

//            redisUtil.set(String.format(RedisKey.SCENE_BUILD_FINISH_NUM, sceneCode), "1");

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

            Map<String, Object> param = new HashMap<>();
            try {
                param.put("event_type", "计算成功");
                param.put("event_content", "计算成功");
                param.put("scene_num", sceneCode);
                param.put("event_time", new Date());
                param.put("ryid", scenePlusService.getRyIdByNum(sceneCode));
                jmgaService.sendStatus(param);
            }catch (Exception e){
                log.info("推送事件失败,param:{}", param);
            }

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

            scenePlusService.update(new LambdaUpdateWrapper<ScenePlus>()
                    .set(ScenePlus::getSceneStatus, SceneStatus.FAILD.code())
                    .eq(ScenePlus::getNum, sceneCode));

            this.sendFailToLaser(sceneCode);

            Map<String, Object> param = new HashMap<>();
            try {
                param.put("event_type", "计算失败");
                param.put("event_content", "计算结果处理失败");
                param.put("scene_num", sceneCode);
                param.put("event_time", new Date());
                param.put("ryid", scenePlusService.getRyIdByNum(sceneCode));
                jmgaService.sendStatus(param);
            }catch (Exception ex){
                log.info("推送事件失败,param:{}", param);
            }

            throw e;
        } finally {
            Map<String, Object> sceneStatusParam = new HashMap<>();
            sceneStatusParam.put("num", sceneCode);
            sceneStatusParam.put("status", message.getBuildSuccess() ? 1 : -1);
//            commonService.sendUpdateSceneStatusMqToQueues(sceneStatusParam);

            if(StrUtil.isNotEmpty(batchIds)){
                origFileUploadBatchService.update(new LambdaUpdateWrapper<OrigFileUploadBatch>().set(OrigFileUploadBatch::getStatus, 3).in(OrigFileUploadBatch::getBatchId, batchIds.split(",")));
            }

        }
    }



    private Integer uploadFreespace(String num, String path, Map<String, String> map){
        String floor0pngPath = "/results/floorplan/floor_0.png";
        String plyPath = path + "/results/laserData/cover/final_freespace.ply";
        String pngPath = path + "/results/laserData/cover/final_freespace.png";
        String infoJsonPath = path + "/results/laserData/cover/info.json";
        Integer hasAi = CommonStatus.NO.code().intValue();
        if(FileUtil.exist(floor0pngPath) || FileUtil.exist(plyPath)){
            hasAi = CommonStatus.YES.code().intValue();
            map.put(plyPath, String.format(UploadFilePath.IMG_VIEW_PATH, num) + "cover/" + FileUtil.getName(plyPath));
        }
        if(FileUtil.exist(pngPath)){
            map.put(pngPath, String.format(UploadFilePath.IMG_VIEW_PATH, num) + "cover/" + FileUtil.getName(pngPath));
        }
        if(FileUtil.exist(infoJsonPath)){
            map.put(infoJsonPath, String.format(UploadFilePath.IMG_VIEW_PATH, num) + "cover/" + FileUtil.getName(infoJsonPath));
        }
        return hasAi;
    }

    private void sendMqForBcgn(String num){
        Map<String, String> map = new HashMap<>();
        map.put("num", num);
        mqProducer.sendByWorkQueue("detect-queue", map);
    }

    private void sendMqForAiPano(String num){
        Map<String, String> map = new HashMap<>();
        map.put("num", num);
        mqProducer.sendByWorkQueue("detect-queue-pano", map);
    }

    private Map<String, String> getUploadFiles(ScenePlus scenePlus,String path,Integer cameraType,JSONObject fdageData) 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);
                }
            }
        }

        //exportMeshObj这个是字段由app写入的
        boolean genModel = true;//是否生成模型 默认生成，深时场景要根据 exportMeshObj判断是否生成
        if(!ObjectUtils.isEmpty(cameraType)
                && cameraType == 14
                && (!fdageData.containsKey("exportMeshObj") || fdageData.getIntValue("exportMeshObj") != 1)){
            genModel = false;
        }
        boolean gen3dTiles = true;//是否生成3dtiles模型 默认生成
        if(!ModelKind.THREE_D_TILE.code().equals(modelKind)
                || CollUtil.isEmpty(sdTilesSceneSourceList)
                || !sdTilesSceneSourceList.contains(scenePlus.getSceneSource())){
            gen3dTiles = false;
        }

        if(genModel){
            if (!gen3dTiles) {
                String damPath = path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam";
                CreateObjUtil.convertTxtToDam(path + File.separator + "results" + File.separator + "tex" + File.separator + "modeldata.txt", damPath);
//                FileUtil.writeBytes(ZipUtil.gzip(new File(damPath)), damPath);
                map.put(damPath, imagesPath + ConstantFileName.modelUUID + "_50k.dam");
            }else{
                List<String> list = FileUtils.list(new File(path + File.separator + "results" + File.separator + ModelKind.THREE_D_TILE.code()));
                if(CollUtil.isEmpty(list)){
                    log.error("3dtiles目录异常，3dtiles地址：{}", new File(path + File.separator + "results" + File.separator + ModelKind.THREE_D_TILE.code()));
                    throw new Exception("3dtiles目录异常");
                }
                list.stream().forEach(str->{
                    map.put(str, str.replace(path + File.separator + "results" + File.separator, imagesPath));
                });
            }
        }

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

        log.info("数据转换完成：" + projectNum);
        if(!new File("/mnt/4Dkankan/scene/data" + File.separator + "data" + projectNum).exists()){
            FileUtil.mkdir("/mnt/4Dkankan/scene/data" + File.separator + "data" + projectNum);
        }
//        map.put(resultsPath + "floorplan.json", dataViewPath + "floor.json");
        map.put(resultsPath + "floorplan_cad.json", dataViewPath + "floorplan_cad.json");
        map.put(path + File.separator + "capture/stitch_params.txt", dataViewPath + "stitch_params.txt");
        map.put(path + File.separator + "capture/Up.xml", dataViewPath + "Up.xml");
        map.put(path + File.separator + "capture/Up2.xml", dataViewPath + "Up2.xml");
        map.put(path + File.separator + "capture/Up.txt", dataViewPath + "Up.txt");
        map.put(path + File.separator + "capture/Up2.txt", dataViewPath + "Up2.txt");
        return map;

    }

    private JSONObject getFdageData(String dataFdagePath) {
        log.info("dataFdagePath 文件路径 ：{}", dataFdagePath);
        String data = FileUtils.readFile(dataFdagePath);
        //获取data.fdage的内容
        JSONObject dataJson = new JSONObject();
        if(data!=null){
            dataJson = JSONObject.parseObject(data);
        }
        return dataJson;
    }

    private void uploadFloorCad(String path, String num, Map<String, String> uploadFiles){

        //户型图上传
        String  dataViewPath = UploadFilePath.DATA_VIEW_PATH + "floor-cad-%s.%s";
        String floorCadPath = path + "/results/floorplan_cad";
        List<String> floorCadList = FileUtils.getFileList(floorCadPath);
        if(CollUtil.isNotEmpty(floorCadList)){
            floorCadList.stream().forEach(str->{
                String substring = str.substring(str.lastIndexOf(File.separator) + 1);
                String[] arr = substring.split("floor");
                String[] arr2 = arr[1].split("\\.");
                uploadFiles.put(str, String.format(dataViewPath, num, arr2[0], arr2[1]));
            });
        }

    }

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

        Integer status = 1;
        if(scenePlus.getSceneSource() == 4 || scenePlus.getSceneSource() == 5){//如果是激光场景，需要激光系统那边完全处理好之后再发mq通知更新状态
            status = 0;
        }

        // 上传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());

        Map<String,String> headers = new HashMap<>();
        headers.put(HttpHeaders.CONTENT_TYPE, ContentType.JSON.getValue());
        fYunFileService.uploadFile(ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json", dataViewPath + "status.json", headers);
    }

    private void createQrCode(String num, ScenePlusExt scenePlusExt, String qrLogo) {
        String localLogoPath = null;
        if (!ObjectUtils.isEmpty(qrLogo)) {
            try {
                localLogoPath = ConstantFilePath.AGENT_PATH + qrLogo.substring(qrLogo.lastIndexOf("//") + 1);
                HttpUtil.downloadFile(qrLogo, localLogoPath);
            } catch (Exception e) {
                log.error("公司logo下载失败：{}", qrLogo);
                localLogoPath = null;
            }
        }
        //生成二维码
        String outPathZh = ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+ num +".png";
        String outPathEn = ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+ num +"_en.png";
        QrConfig qrConfig = QrConfig.create();
        qrConfig.setWidth(1024);
        qrConfig.setHeight(1024);
        if(StrUtil.isNotEmpty(localLogoPath)){
            qrConfig.setImg(localLogoPath);
        }
        QrCodeUtil.generate(scenePlusExt.getWebSite(), qrConfig, FileUtil.file(outPathZh));
        QrCodeUtil.generate(scenePlusExt.getWebSite() + "&lang=en", qrConfig, FileUtil.file(outPathEn));
        //上传二维码
        fYunFileService.uploadFile(outPathZh, String.format(UploadFilePath.DOWNLOADS_QRCODE, num) + num + ".png");
        fYunFileService.uploadFile(outPathEn, String.format(UploadFilePath.DOWNLOADS_QRCODE, num) + num + "_en.png");

        if(!ObjectUtils.isEmpty(localLogoPath)){
            FileUtils.deleteFile(localLogoPath);
        }
    }

    private void pushMsgToApp(Integer pushChannel, String pushToken, int cameraType, String sceneName, String webSite){
        log.info("推送消息，渠道是 {}, 手机token是 {}", pushChannel, pushToken);
        if(Objects.isNull(pushChannel) || StrUtil.isBlank(pushToken)){
            return;
        }

        String title = sceneName + "计算完成";
        String body = "您上传的" + sceneName + "计算完成，点击查看";

        try{
            if(FYunTypeEnum.AWS.code().equals(fYunFileService.getFyunType())){
                PushMsgUtil.googlePushMsg(ConstantFilePath.BASE_PATH + "/refreshToken.json", pushToken,
                        title, body , webSite);
                return;
            }

            PushMessageConfig pushConfig = null;
            if(pushChannel == 0){
                if(cameraType == 10 || cameraType == 13){
                    //ios
                    pushConfig = new PushMessageConfig(PushMessageConfig.IOS_KEY_Z, PushMessageConfig.IOS_SECRET_Z);
                    pushConfig.sendIOSUnicast(pushToken,  "四维看看Minion",title, body, webSite);
                }else {
                    //ios
                    pushConfig = new PushMessageConfig(PushMessageConfig.IOS_KEY, PushMessageConfig.IOS_SECRET);
                    pushConfig.sendIOSUnicast(pushToken, "四维看看Pro",title, body, webSite);
                }
            }else {
                if(cameraType == 10 || cameraType == 13){
                    //ios
                    //安卓
                    pushConfig = new PushMessageConfig(PushMessageConfig.ANDROID_KEY_Z, PushMessageConfig.ANDROID_SECRET_Z);
                    pushConfig.sendAndroidUnicast2(pushToken, "四维看看Minion",title, body, webSite);
                }else {
                    //安卓
                    pushConfig = new PushMessageConfig(PushMessageConfig.ANDROID_KEY, PushMessageConfig.ANDROID_SECRET);
                    pushConfig.sendAndroidUnicast(pushToken, "四维看看Pro",title, body, webSite);
                }
            }
            log.info("消息推送结束！");
        }catch (Exception e){
            log.error("推送消息失败：", e);
        }
    }

    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()) {
                fYunFileService.copyFileInBucket(entry.getValue(), entry.getKey());
        }
    }

    private JSONObject getVideosJson(String path, Integer videoVersion, 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(Objects.nonNull(videoVersion) && videoVersion >= 4){
            videosJson.put("version", 3);
            videosJson.put("upPath", String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "Up.xml");
            if(cameraType == 13 || cameraType == 14){
                //转台相机
                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
            }
        }else {
            videosJson.put("version", 1);
            videosJson.put("upPath", String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "Up2.xml");
            if(cameraType == 13 || cameraType == 14){
                //转台相机
                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
            }
        }

        if(cameraType == 5 || cameraType == 6){
            videosJson.put("version", 1);
            videosJson.put("upPath", String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "stitch_params.txt");
        }

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

        scenePlusExt.setSpace(space);
        scenePlusExt.setComputeTime(computeTime.toString());
        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);

        //统计点位数量
        Map<String, Integer> result = this.getShootCount(scenePlusExt);
        Integer shootCount = result.get("shootCount");
        Integer mixture = result.get("mixture");
        scenePlusExt.setShootCount(shootCount);
        scenePlusExt.setMixture(mixture);

        scenePlusExtService.updateById(scenePlusExt);
    }

    private Map<String, Integer> getShootCount(ScenePlusExt scenePlusExt){

        Map<String, Integer> result = new HashMap<>();

        Integer shootCount = 0;
        Integer mixture = Objects.isNull(scenePlusExt.getMixture()) ? 0 : scenePlusExt.getMixture();
        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){
            if(Objects.nonNull(scenePlusExt.getLocation()) && scenePlusExt.getLocation() == 6){
                mixture = CommonStatus.YES.code().intValue();
            }
        }else{
            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();
                }
            }
            mixture = CommonStatus.NO.code().intValue();
        }

        result.put("shootCount", shootCount);
        result.put("mixture", mixture);

        return result;
    }

    public static void main(String[] args) {
//        JSONObject dataFdageObj = JSON.parseObject(null);
//        System.out.println(dataFdageObj);

        String test ="{\"rebuild\":\"0\",\"flexibility\":0,\"isStandardization\":null,\"createTime\":null,\"resultReceiverMqName\":null,\"buildContext\":{\"sceneNum\":\"SG-jm-JT77TjCZwF5\",\"cameraType\":\"14\"},\"computeTime\":446,\"buildSuccess\":true,\"path\":\"/mnt/data/bpvt00006/1328767184540794880/bpvt00006_202412301634030230\",\"hostName\":null,\"ext\":{\"deleteExtras\":true,\"detFloorplan\":{\"0\":true,\"4\":true,\"3\":true,\"1\":true},\"location\":4,\"linkPanTargetList\":[\"/mnt/data/bpvt00006/1328767184540794880/bpvt00006_202412301634030230/linkPan/panorama/0_pano_0\",\"/mnt/data/bpvt00006/1328767184540794880/bpvt00006_202412301634030230/linkPan/panorama/1_pano_0\"]},\"errorType\":null}";
        BuildSceneResultMqMessage message = JSONObject.parseObject(test, BuildSceneResultMqMessage.class);
        Map<String, Object> ext = message.getExt();
        JSONObject detFloorplanObj = (JSONObject)ext.get("detFloorplan");
        for (String s : detFloorplanObj.keySet()) {
            System.out.println(s + ":" + detFloorplanObj.getBoolean(s));

        }
    }


    public boolean uploadHouseTypeJson(String num, String dataSource) {
        String floorPlanCardFilePath = dataSource + File.separator + "results/floorplan_cad.json";
        if (!new File(floorPlanCardFilePath).exists()) {
            log.warn("floorplan_cad.json 文件不存在，文件路径：{}", floorPlanCardFilePath);
            return false;
        }
        JSONObject json = CreateHouseJsonUtil.createHouseTypeJsonByCad(floorPlanCardFilePath);
        if(Objects.isNull(json)){
            return false;
        }
        String hourseTypeJsonPath = String.format(UploadFilePath.USER_VIEW_PATH, num) + "houseType.json";
        fYunFileService.uploadFile(json.toJSONString().getBytes(), hourseTypeJsonPath);
        hourseTypeJsonPath = String.format(UploadFilePath.USER_EDIT_PATH, num) + "houseType.json";
        fYunFileService.uploadFile(json.toJSONString().getBytes(), hourseTypeJsonPath);

        return true;
    }

    private void sendFailToLaser(String num){
        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(num);
        if(SceneSource.JG.code() != scenePlus.getSceneSource().intValue() && SceneSource.SG.code() != scenePlus.getSceneSource().intValue()){
            return;
        }
        Map<String, Object> params = new HashMap<>();
        params.put("sceneCode", num);
        params.put("status", 1);
        params.put("createTime", DateUtil.date2String(scenePlus.getCreateTime(), null));
        params.put("algorithmTime", DateUtil.date2String(Calendar.getInstance().getTime(), null));
        params.put("sceneSource", scenePlus.getSceneSource());
        fdkkLaserService.syncFailResult(params);
    }
}