package com.fdkankan.contro.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.exceptions.ExceptionUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.ZipUtil;
import cn.hutool.crypto.digest.MD5;
import cn.hutool.extra.qrcode.QrCodeUtil;
import cn.hutool.extra.qrcode.QrConfig;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.*;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.common.util.*;
import com.fdkankan.contro.bean.SendCallAlgorithmDetail;
import com.fdkankan.contro.common.Result;
import com.fdkankan.contro.constant.*;
import com.fdkankan.contro.entity.*;
import com.fdkankan.contro.enums.CameraTypeEnum;
import com.fdkankan.contro.httpclient.MyClient;
import com.fdkankan.contro.mapper.ISceneFileBuildMapper;
import com.fdkankan.contro.service.*;
import com.fdkankan.contro.util.HttpUtilExt;
import com.fdkankan.contro.vo.ResponseSceneFile;
import com.fdkankan.contro.vo.ScenePlusVO;
import com.fdkankan.contro.vo.SendCallAlgorithmParam;
import com.fdkankan.fyun.config.FYunFileConfig;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.fyun.local.constant.LocalConstants;
import com.fdkankan.image.MatrixToImageWriterUtil;
import com.fdkankan.model.constants.ConstantFilePath;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.model.utils.SceneUtil;
import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisLockUtil;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.web.response.ResultData;
import com.fdkankan.web.util.RSAEncrypt;
import lombok.extern.slf4j.Slf4j;
import net.lingala.zip4j.core.ZipFile;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
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.http.*;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.ObjectUtils;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;

/**
 * <p>
 * 场景文件建模表 服务实现类
 * </p>
 *
 * @author dengsixing
 * @since 2021-12-23
 */
@RefreshScope
@Slf4j
@Service
public class SceneFileBuildServiceImpl extends ServiceImpl<ISceneFileBuildMapper, SceneFileBuild> implements ISceneFileBuildService {

    private static final String SPLICE = "#";

    private static final String sendCallAlgorithmPath = "/mnt/sendCallAlgorithm/";

    private static final String zipPassword = "a3ad34136de359536af553f9e7f3cefd";

    private static final String URL_ADD_UCENTER_USER = "/service/manage/inner/addUcenterUser";

    @Value("${main.url}")
    private String mainUrl;
    @Value("${fyun.type}")
    private String fyunType;

    @Value("${scene.pro.new.url}")
    private String sceneProNewUrl;

    @Value("${scene.pro.v3.url}")
    private String sceneProV3Url;

    @Value("${queue.modeling.modeling-pre}")
    private String queueModelingPre;

    @Value("${queue.modeling.v3.modeling-pre}")
    private String queueV3ModelingPre;

    @Value("${queue.modeling.intermit.modeling-pre}")
    private String queueIntermitModelingPre;

    @Value("${v3.controlUrl:#{null}}")
    private String v3controlUrl;

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

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

    @Value("#{'${camType.laser:}'.split(',')}")
    private List<Integer> laserCamTypeList;

    @Value("${build.notSupport.beforeTime:202203}")
    private String jgNotSupportBuildTime;

    @Value("${4dkk.fdService.basePath}")
    private String fdServiceUrl;

    @Value("${user.password.key:0000000856753656}")
    private String userPasswordKey;

    @Value("${user.password.iv:pwel781esd6wglxm}")
    private String userPasswordIv;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private IScenePlusExtService scenePlusExtService;

    @Autowired
    private IScene3dNumService scene3dNumService;

    @Autowired
    private IScenePlusService scenePlusService;

    @Autowired
    private RabbitMqProducer rabbitMqProducer;

    @Autowired
    private ISceneEditInfoService sceneEditInfoService;
    @Autowired
    private ISceneEditControlsService sceneEditControlsService;
    @Autowired
    private ISceneEditInfoExtService sceneEditInfoExtService;

    @Autowired
    private ISceneCooperationService sceneCooperationService;
    @Autowired
    private ISceneResourceCameraService sceneResourceCameraService;
    @Autowired
    private ISceneResourceCooperationService sceneResourceCooperationService;

    @Autowired
    private ICameraService cameraService;

    @Autowired
    private ICameraDetailService cameraDetailService;

    @Autowired
    private IUserService userService;

    @Autowired
    private ISceneFileUploadService sceneFileUploadService;

    @Resource
    private ICompanyService companyService;

    @Resource
    private FYunFileServiceInterface fYunFileService;

    @Autowired
    private FYunFileConfig fYunFileConfig;

    @Autowired
    private RedisLockUtil redisLockUtil;

    @Autowired
    private IScenePreService scenePreService;

    private RestTemplate restTemplate = new RestTemplate();

    @Autowired
    private ISceneCopyDistinctEnvService sceneCopyDistinctEnvService;

    @Autowired
    private ISceneCopyLogService sceneCopyLogService;

    @Autowired
    private ISceneCleanOrigService sceneCleanOrigService;

    @Autowired
    private ICommonService commonService;

    @Autowired
    private IExceedSpaceSceneService exceedSpaceSceneService;

    @Autowired
    private ISceneColdStorageLogService sceneColdStorageLogService;

    @Autowired
    private ISceneColdStorageService sceneColdStorageService;
    @Autowired
    private IntermitSceneService intermitSceneService;
    @Autowired
    private ISceneRebuildLogService sceneRebuildLogService;
    @Autowired
    private ISceneUploadCountService sceneUploadCountService;

    @Autowired
    private ISceneProService sceneProService;

    @Autowired
    private ISceneProEditService sceneProEditService;

    @Autowired
    private IFdkkLaserService fdkkLaserService;

    @Resource
    private MyClient myClient;

    @Autowired
    IJySceneAuthService jySceneAuthService;

    @Autowired
    private IJyUserService jyUserService;

    @Autowired
    private IOrigFileUploadService origFileUploadService;

    @Autowired
    private IOrigFileUploadBatchService origFileUploadBatchService;

    @Autowired
    private IJmgaService jmgaService;

    @Autowired
    private ISceneOrigBdService sceneOrigBdService;
    @Autowired
    private ISceneFilenameService sceneFilenameService;
    @Autowired
    private UploadShootingService uploadShootingService;

    @Override
    public SceneFileBuild findByFileId(String fileId) {

        List<SceneFileBuild> list = this.list(new LambdaQueryWrapper<SceneFileBuild>().eq(SceneFileBuild::getFileId, fileId)
                .orderByDesc(SceneFileBuild::getId));
        if(CollUtil.isEmpty(list)){
            return null;
        }
        return list.get(0);
    }

    @Override
    public ResponseSceneFile preUpload(String params) throws Exception {
        log.info("preUpload-params: "+params);
        if (StrUtil.isEmpty(params)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        params = params.replaceAll("%2B", "+");
        Base64 base64 = new Base64();
        String cipher = params;
        // 私钥解密过程
        byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile()),
                base64.decode(cipher));
        String restr = new String(res, "UTF-8");
        log.debug("preUpload-params解密结果：" + restr);
        String[] strArr = restr.split(SPLICE);
        if (strArr.length != 5) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        String mac = strArr[0];
        String totalPicNum = strArr[1];
        String chunks = strArr[2];
        String folderName = strArr[3];

        if (StrUtil.isEmpty(mac)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5044);
        }
        if (totalPicNum == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5045);
        }
        if (chunks == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5046);
        }
        if (folderName == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5047);
        }

        log.info("mac：{} 准备上传文件,folderName:{}", mac, folderName);
        ResponseSceneFile responseSceneFile = new ResponseSceneFile();

        // 检测是否有生成
        String fileId = redisUtil.get(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName));
        if (StrUtil.isEmpty(fileId)) {
            SceneFileBuild sceneFileBuild = this.findByUnicode(folderName);
            if (sceneFileBuild != null) {
                fileId = sceneFileBuild.getFileId();
            }
        }
        if(StrUtil.isNotEmpty(fileId)){

            //校验目录是否被上锁，如果上锁，抛出错误（避免删除原始资源定时任务执行过程中，有场景补拍重新上传）
            String homePath = redisUtil.get(String.format(RedisKey.SCENE_OSS_HOME_DIR_DELETE, folderName));
            if(StrUtil.isNotEmpty(homePath)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5073);
            }
            //如果原始资源目录不是正在被定时任务删除中，就加上上传锁，并正常返回
            homePath = ConstantFilePath.OSS_PREFIX.concat(mac).concat("/").concat(fileId).concat("/").concat(folderName);
            redisUtil.set(String.format(RedisKey.SCENE_OSS_HOME_DIR_UPLOAD, folderName), homePath, RedisKey.CAMERA_EXPIRE_7_TIME);

            responseSceneFile.setFileId(fileId);
            redisUtil.set(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName), fileId, 2 * 24 * 60 * 60);
            return responseSceneFile;
        }

        // 加锁
        boolean lock = redisLockUtil.lock(String.format(RedisConstants.FOLDER_LOCK_BUILD, folderName), 120);
        if (!lock) {
            throw new BusinessException(ErrorCode.FAILURE_CODE_5052);
        }

        // 查找场景表
        LambdaQueryWrapper<ScenePro> proWrapper = new LambdaQueryWrapper<>();
        proWrapper.like(ScenePro::getDataSource, "/" + folderName);
        ScenePro pro = sceneProService.getOne(proWrapper);

        String dataSource = null;

        if (!ObjectUtils.isEmpty(pro)) {
            dataSource = pro.getDataSource();
        } else {
            dataSource = scenePlusService.getDataSourceLikeUnicode("/" + folderName);
        }

        if (StrUtil.isNotEmpty(dataSource)) {
            log.info("从数据库中查到与 fileId:{} 匹配的路径为:{}", fileId, dataSource);
            int n = dataSource.split("/").length;
            if (n > 1) {
                fileId = dataSource.split("/")[n - 2];
            }
        }

        if (StrUtil.isEmpty(fileId)) {
            fileId = new SnowflakeIdGenerator(0, 0).nextId() + "";
            log.info("新生成build数据,{}", fileId);
        }

        SceneFileBuild sceneFileBuild = new SceneFileBuild();
        sceneFileBuild.setChildName(mac);
        sceneFileBuild.setFileId(fileId);
        sceneFileBuild.setRecStatus("A");
        sceneFileBuild.setUnicode(folderName);
        sceneFileBuild.setTotalPicNum(Integer.valueOf(totalPicNum));
        sceneFileBuild.setChunks(Integer.valueOf(chunks));
        sceneFileBuild.setCreateTime(new Date());
        this.save(sceneFileBuild);
        redisUtil.set(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName), fileId, 2 * 24 * 60 * 60);
        redisUtil.set(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId), folderName, 2 * 24 * 60 * 60);

        responseSceneFile.setFileId(fileId);
        return responseSceneFile;
    }

    public SceneFileBuild findByUnicode(String unicode) {
        List<SceneFileBuild> list = this.list(new QueryWrapper<SceneFileBuild>()
                .eq("unicode", unicode)
                .orderByDesc("id"));
        if(CollUtil.isEmpty(list))
            return null;

        return list.get(0);
    }

    public ScenePlusVO buildScene(String fileId, String prefix,JSONObject jsonObject,String buildType,long cameraType, User user) throws Exception{
        //调用createScene方法生成scene数据和加入算法队列
        String sceneNum = "";


        String cameraName = jsonObject.getJSONObject("cam").getString("uuid");
        String unicode = jsonObject.getString("creator") + "_" + jsonObject.getString("uuidtime");

        int camType = jsonObject.getJSONObject("cam").getIntValue("type");
        String cameraInStoreUrl = fdServiceUrl + ApiConstant.URL_CAMERA_INSTORE;
        Map<String, Object> cameraInStoreParams = new HashMap<>();
        cameraInStoreParams.put("cameraType", camType);
        cameraInStoreParams.put("snCode", jsonObject.getString("creator"));
        ResultData post = myClient.post(cameraInStoreUrl, cameraInStoreParams);
        log.info("---------cameraInStore result:{}-----------", post);

        if(Objects.isNull(user)){
            JSONObject configJson = JSONObject.parseObject(fYunFileService.getFileContent(ConstantFilePath.OSS_PREFIX + prefix + "config.json"));
            String folderName = configJson.getString("id");
            String customUserId = configJson.getString("customUserId");
            String customUserName = configJson.getString("customUserName");
            String customUserPwd = configJson.getString("customUserPwd");
            if(StrUtil.isBlank(folderName) || StrUtil.isBlank(jsonObject.getString("creator"))){
                throw new RuntimeException("config.json 文件有误！");
            }

            //调注册用户接口
            Map<String, Object> params = new HashMap<>();
            params.put("ryId", customUserId);
            params.put("ryNo", customUserName);
//        params.put("nickName", customUserName);//去掉昵称，又燕海的接口进行判断
            params.put("password", AesUtil.encryptCBC(customUserPwd, userPasswordKey, userPasswordIv, AesUtil.ALMODE_CBC_NOPADDING));
            String url = fdServiceUrl.concat(ApiConstant.URL_ADD_UCENTER_USER);
            myClient.post(url, params);
            JyUser jyUser = jyUserService.getByRyId(customUserId);
            user = userService.getById(jyUser.getUserId());
            if(Objects.isNull(jyUser)){
                throw new RuntimeException("注册用户失败");
            }
        }


        Camera camera = cameraService.getByChildName(cameraName);

        if (camera == null) {
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }

        CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
        if (cameraDetail == null) {
            log.error("该相机详情不存在：" + cameraName);
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }

        //查看场景中的文件目录是否有改文件id，有则重新计算改场景，无则新建场景
        ScenePlus scenePlus = scenePlusService.getByFileId("/" + fileId + "/");
        int rebuild = CommonStatus.YES.code();
        if (ObjectUtils.isEmpty(scenePlus)) {

            //清除超容量场景记录
            exceedSpaceSceneService.repeal(camera.getId(), fileId, unicode);

            sceneNum = scene3dNumService.generateSceneNum(cameraDetail.getType());

            rebuild = CommonStatus.NO.code();
        } else {
            sceneNum = scenePlus.getNum();
            sceneCopyLogService.checkCanBuild(sceneNum);
            if (scenePlus.getSceneStatus().equals(SceneStatus.wait.code())) {
                log.info(scenePlus.getNum() + ":场景处于计算中，不能再计算");
                return null;
            }
        }
        if (sceneNum == null) {
            log.error("大场景序号为空：" + sceneNum);
            throw new BusinessException(ErrorCode.FAILURE_CODE_5005);
        }

        //如果是相机计算容量的模式是场景个数模式，则需要拦截计算
        if(rebuild == CommonStatus.NO.code()){//新场景需要校验容量是否超出限制
            boolean exceedSpace = exceedSpaceSceneService.cehckExceedSpace(sceneNum, cameraDetail, cameraName, fileId, unicode);
            if(exceedSpace){
                ScenePlusVO scenePlusVO = new ScenePlusVO();
                scenePlusVO.setNum(sceneNum);
                scenePlusVO.setSceneStatus(SceneStatus.EXCEED_SPACE.code());
                return scenePlusVO;
            }
        }

        String dataSource = cameraName.replace("4DKKPRO_", "").replace("-fdage", "").toLowerCase() + File.separator +
                fileId + File.separator + unicode;
        if (cameraType == 14) {
            dataSource = ConstantFilePath.BUILD_MODEL_LASER_PATH +dataSource;
        } else {
            dataSource = ConstantFilePath.BUILD_MODEL_PATH + dataSource;
        }

        String imgViewPath = String.format(UploadFilePath.IMG_VIEW_PATH, sceneNum);

        String icon = null;
        if (!ObjectUtils.isEmpty(jsonObject.getString("icon"))) {
            fYunFileService.copyFileInBucket(ConstantFilePath.OSS_PREFIX + prefix + jsonObject.getString("icon"),imgViewPath + jsonObject.getString("icon"));
            icon = fYunFileConfig.getHost() + imgViewPath + jsonObject.getString("icon");
            log.info("上传icon成功....");
        }

        return buildScenePost(dataSource, jsonObject, buildType, cameraType, sceneNum, camera, cameraDetail, rebuild,icon, user);
    }

    private ScenePlusVO buildScenePost(String dataSource, JSONObject jsonObject, String buildType, long cameraType,
                                       String sceneNum, Camera camera, CameraDetail cameraDetail, int rebuild,String icon, User user) throws Exception {
        String imgViewPath = String.format(UploadFilePath.IMG_VIEW_PATH, sceneNum);

        String userName = null;
        if (!ObjectUtils.isEmpty(cameraDetail.getUserId())) {
//            SSOUser user = userService.getSSOUserByUserId(cameraDetail.getUserId());
            userName = ObjectUtils.isEmpty(user) ? null : user.getUserName();
        }

        JSONObject firmwareVersion = new JSONObject();
        if (!ObjectUtils.isEmpty(jsonObject.getString("camSoftwareVersion"))) {
            firmwareVersion.put("camSoftwareVersion", jsonObject.getString("camSoftwareVersion"));
        }

        if (!ObjectUtils.isEmpty(jsonObject.getString("version"))) {
            firmwareVersion.put("version", jsonObject.getString("version"));
        }

        String sceneUrl = "/" + sceneProNewUrl;

        //重算的场景，先移除该场景对应的容量
        if (rebuild == 1) {
            scenePlusService.resetSpace(sceneNum);
        } else {
            //上传log-main.png
            fYunFileService.uploadFile(ConstantFilePath.LOGO_PATH + "logo-main.png", imgViewPath + "logo-main.png");
            fYunFileService.uploadFile(ConstantFilePath.LOGO_PATH + "logo-main-en.png", imgViewPath + "logo-main-en.png");
        }
        String algorithm = jsonObject.getString("location") != null && "1".equals(jsonObject.getString("location")) ? "sfm" : "slam";
        String unicode = jsonObject.getString("creator") + "_" + jsonObject.getString("uuidtime");

        ScenePlusVO scenePlusVO = this.createScenePlus(sceneNum, camera.getId(), camera.getChildName(), jsonObject.getString("creator"),
                jsonObject.getString("pwd"), unicode,cameraType,jsonObject.getJSONObject("cam").getIntValue("type"), dataSource, icon,  user.getId(), userName,algorithm,jsonObject.getInteger("location"),
                jsonObject.getJSONArray("points").size(), jsonObject.getString("name"), jsonObject.getString("info"),
                jsonObject.getInteger("scenetype"), jsonObject.getString("gps"), rebuild,
                jsonObject.getInteger("resolution"), firmwareVersion.toString(), sceneUrl, buildType, cameraDetail.getCooperationUser());

        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneNum);
        ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
        boolean isObj = jsonObject.containsKey("exportMeshObj") && jsonObject.getIntValue("exportMeshObj") == 1;
        scenePlusExt.setIsObj(isObj ? CommonStatus.YES.code() : CommonStatus.NO.code());
        scenePlusExtService.updateById(scenePlusExt);

        //上传app状态文件
        commonService.uploadStatusJson(sceneNum, scenePlusVO.getSceneStatus(),
                scenePlusVO.getWebSite(),scenePlusVO.getThumb(),PayStatus.NOT_PAY.code(),
                String.format(UploadFilePath.DATA_VIEW_PATH, sceneNum));

        BuildSceneCallMessage mqMessage = getBuildSceneMqMessage(sceneNum, cameraType, algorithm, jsonObject, buildType,
                scenePlusVO.getDataSource());
        mqMessage.getExt().put("uuid", unicode);

        if (cameraDetail.getCompanyId() != null) {
            Company company = companyService.getById(cameraDetail.getCompanyId());
            if (company != null && !ObjectUtils.isEmpty(company.getCalculateFlexibility()) && !company.getCalculateFlexibility()) {
                mqMessage.setFlexibility(-1);
            }
        }
        mqMessage.getExt().put("deleteExtras", true);
        if(jsonObject.getIntValue("location") == 7){
            //发送到全景看看进行初始化
            intermitSceneService.sendMq(scenePlusVO.getNum(), jsonObject, CommonSuccessStatus.WAITING.code());
            rabbitMqProducer.sendByWorkQueue(queueIntermitModelingPre, mqMessage);
        }else{
            rabbitMqProducer.sendByWorkQueue(queueModelingPre, mqMessage);
        }

        return scenePlusVO;
    }

    public ScenePlusVO buildV3Scene(ScenePro scenePro,String fileId, String prefix,JSONObject jsonObject,String buildType,long cameraType) throws Exception{

        sceneCopyLogService.checkCanBuild(scenePro.getNum());

        //调用createScene方法生成scene数据和加入算法队列
        String cameraName = jsonObject.getJSONObject("cam").getString("uuid");
        String unicode = jsonObject.getString("creator") + "_" + jsonObject.getString("uuidtime");

        Camera camera = cameraService.getByChildName(cameraName);

        if (camera == null) {
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }

        CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
        if (cameraDetail == null) {
            log.error("该相机详情不存在：" + cameraName);
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }

        String sceneNum = scenePro.getNum();
        if (scenePro.getStatus().equals(SceneStatus.wait.code())) {
            log.info(scenePro.getNum() + ":场景处于计算中，不能再计算");
            return null;
        }

        String localDataPath = String.format(ConstantFilePath.DATABUFFER_FORMAT, sceneNum);
        String imgViewPath = String.format(ConstantFilePath.IMAGE_PATH_FORMAT, sceneNum);
        String dataViewPath = String.format(ConstantFilePath.DATA_PATH_FORMAT, sceneNum);

        String userName = null;
        if (!ObjectUtils.isEmpty(cameraDetail.getUserId())) {
            SSOUser user = userService.getSSOUserByUserId(cameraDetail.getUserId());
            userName = ObjectUtils.isEmpty(user) ? null : user.getUserName();
        }

        String icon = null;
        if (!ObjectUtils.isEmpty(jsonObject.getString("icon"))) {
            fYunFileService.copyFileInBucket(ConstantFilePath.OSS_PREFIX + prefix + jsonObject.getString("icon"),imgViewPath + jsonObject.getString("icon"));
            icon = fYunFileConfig.getHost() + imgViewPath + jsonObject.getString("icon");
            log.info("上传icon成功....");
        }

        JSONObject firmwareVersion = new JSONObject();
        if (!ObjectUtils.isEmpty(jsonObject.getString("camSoftwareVersion"))) {
            firmwareVersion.put("camSoftwareVersion", jsonObject.getString("camSoftwareVersion"));
        }

        if (!ObjectUtils.isEmpty(jsonObject.getString("version"))) {
            firmwareVersion.put("version", jsonObject.getString("version"));
        }

        //删除oss的houst_floor.json(国际版可能会卡住)
        fYunFileService.deleteFile(dataViewPath + "houst_floor.json");

        String algorithm = jsonObject.getString("location") != null && "1".equals(jsonObject.getString("location")) ? "sfm" : "slam";

        ScenePlusVO scenePlusVO = this.createScenePro(sceneNum, camera.getId(), camera.getChildName(), jsonObject.getString("creator"),
                jsonObject.getString("pwd"), unicode,cameraType, fileId, icon,  cameraDetail.getUserId(), userName,algorithm,
                jsonObject.getJSONArray("points").size(), jsonObject.getString("name"), jsonObject.getString("info"),
                jsonObject.getInteger("scenetype"), jsonObject.getString("gps"),
                jsonObject.getInteger("resolution"), firmwareVersion.toString(), buildType);

        //上传场景状态文件
        commonService.uploadStatusJson(sceneNum, scenePlusVO.getSceneStatus(),
                scenePlusVO.getWebSite(),scenePlusVO.getThumb(),PayStatus.NOT_PAY.code(),
                String.format(ConstantFilePath.DATA_PATH_FORMAT, sceneNum));

        BuildSceneCallMessage mqMessage = getBuildSceneMqMessage(sceneNum, cameraType, algorithm, jsonObject, buildType,
                scenePlusVO.getDataSource());
        if (cameraDetail.getCompanyId() != null) {
            Company company = companyService.getById(cameraDetail.getCompanyId());
            if (company != null) {
                log.info("复制企业logo");
                SceneProEdit sceneEditInfo = sceneProEditService.getByProId(scenePlusVO.getId());
                if (StrUtil.isNotEmpty(company.getTopLogo())) {
                    fYunFileService.copyFileInBucket(company.getTopLogo(),imgViewPath + "logo-main.png");
                }
                if (StrUtil.isNotEmpty(company.getFloorLogo())) {
                    fYunFileService.copyFileInBucket(company.getFloorLogo(),imgViewPath + "floorLogoImg.png");
                    sceneEditInfo.setFloorLogo("user");
                }

                if (StrUtil.isNotEmpty(company.getQrLogo())) {
                    createQrCode(sceneNum,scenePlusVO.getWebSite(),company.getQrLogo());
                }
                sceneProEditService.updateById(sceneEditInfo);
                if (!ObjectUtils.isEmpty(company.getCalculateFlexibility()) && !company.getCalculateFlexibility()) {
                    mqMessage.setFlexibility(-1);
                }
            }
        }
        rabbitMqProducer.sendByWorkQueue(queueV3ModelingPre, mqMessage);

        return scenePlusVO;
    }

    private void createQrCode(String num, String url, String qrLogo) {
        String localLogoPath = null;
        if (!org.apache.commons.lang3.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(512);
        qrConfig.setHeight(512);
        if(!org.apache.commons.lang3.ObjectUtils.isEmpty(localLogoPath)){
            qrConfig.setImg(localLogoPath);
        }
        QrCodeUtil.generate(url, qrConfig, FileUtil.file(outPathZh));
        QrCodeUtil.generate(url + "&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(!org.apache.commons.lang3.ObjectUtils.isEmpty(localLogoPath)){
            FileUtils.deleteFile(localLogoPath);
        }
    }

    @Override
    public ResultData uploadSuccessBuild(String params, User user) throws Exception {
        log.info("uploadSuccessBuild-params: " + params);
        String preParams = params;
        if (StringUtils.isEmpty(params)) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        params = params.replaceAll("%2B", "+");
        params = params.replaceAll(" ", "+");
        Base64 base64 = new Base64();
        String cipher = params;
        // 私钥解密过程
        byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile()), base64.decode(cipher));
        String restr = new String(res, "UTF-8");
        log.info("uploadSuccessBuild-params解密结果：" + restr);
        String[] strArr = restr.split(SPLICE);
        if (strArr.length != 3) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        String mac = strArr[0];
        String fileId = strArr[1];
        String folderName = redisUtil.get(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId));

        if(StringUtils.isEmpty(folderName)){
            SceneFileBuild fileBuild = findByFileId(fileId);
            if(ObjectUtils.isEmpty(fileBuild)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
            folderName = fileBuild.getUnicode();
            redisUtil.set(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId), folderName,2 * 24 * 60 * 60);
        }
        sceneUploadCountService.resetCountByUuid(folderName);

        StringBuilder prefixBuffer = new StringBuilder(mac).append(File.separator).append(fileId).append(File.separator).append(folderName).append(File.separator);

        String buildType = "V2";
        Long cameraType = 10L;

        String fileUploadedOpName = "fileUploadedOp.cam";
        String fileUploadedOpKey = new StringBuilder( ConstantFilePath.OSS_PREFIX).append(mac).append(File.separator).append(fileId).append(File.separator).append(folderName).append(File.separator).append(fileUploadedOpName).toString();
        if(fYunFileService.fileExist(fileUploadedOpKey)){
            Set<String> notExistsFiles = commonService.checkUploadFile(mac, fileId, folderName, fYunFileConfig.getFyunType());
            if(CollUtil.isNotEmpty(notExistsFiles)){
                log.error("文件缺失, unicode:{}, 缺失文件:{}", folderName, notExistsFiles);
                throw new BusinessException(ModelingControlRespCode.FILE_EMPTY.code(), ModelingControlRespCode.FILE_EMPTY.message());
            }
        }


        if(!fYunFileService.fileExist(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage")){
            log.error("data.fdage文件不存在");
            throw new BusinessException(CameraConstant.FAILURE_6009);
        }

        JSONObject fdageJson = JSONObject.parseObject(fYunFileService.getFileContent(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage"));
        if(ObjectUtils.isEmpty(fdageJson)){
            log.info("data.fdage文件为空！");
            throw new BusinessException(CameraConstant.FAILURE_6009);
        }
        //根据videoVersion判断是V2还是V3版本的算法和页面
        if (fdageJson.containsKey("videoVersion") && StrUtil.isNotEmpty(fdageJson.getString("videoVersion"))) {
            if (fdageJson.getIntValue("videoVersion") >= 4) {
                buildType = "V3";
                cameraType = 11L;
            }
        }
        int camType = fdageJson.getJSONObject("cam").getIntValue("type");
        if(camType == 5){
            cameraType = 6L;
        }

        this.removeUpdateV4(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage", fdageJson);

        // 判断是否是V3的场景
        ScenePro scenePro = sceneProService.getOne(
            new LambdaQueryWrapper<ScenePro>().like(ScenePro::getDataSource, "/".concat(fileId).concat("/")));

//        boolean callV3 = callV3(scenePro, preParams, fdageJson, "api/scene/file/uploadSuccessBuild");
//        if(callV3) return ResultData.ok();


        if (ObjectUtils.isEmpty(scenePro) || (!ObjectUtils.isEmpty(scenePro.getIsUpgrade()) && scenePro.getIsUpgrade() == 1)) {
            buildScene(fileId, prefixBuffer.toString(),fdageJson,buildType,cameraType, user);
        }else{
            buildV3Scene(scenePro,fileId, prefixBuffer.toString(),fdageJson,buildType,cameraType);
        }
        return ResultData.ok();
    }

    private void removeUpdateV4(String dataFdagePath, JSONObject fdageJson){
        Integer updateV4 = fdageJson.getInteger("updateV4");
        if(Objects.isNull(updateV4) || updateV4 == 0){
            return;
        }
        fdageJson.put("updateV4", CommonStatus.NO.code());
        fYunFileService.uploadFile(fdageJson.toJSONString().getBytes(StandardCharsets.UTF_8), dataFdagePath);
    }

    private boolean callV3(ScenePro scenePro, String preParams, JSONObject fdageJson,String api) throws Exception {

        //复制出来的场景不支持补拍上传
        if(Objects.nonNull(scenePro)){
            sceneCopyLogService.checkCanBuild(scenePro.getNum());
        }

        String cameraName = fdageJson.getJSONObject("cam").getString("uuid");

        Camera camera = cameraService.getByChildName(cameraName);

        if (camera == null) {
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }

        CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
        if (cameraDetail == null) {
            log.error("该相机详情不存在：" + cameraName);
            throw new BusinessException(CameraConstant.FAILURE_6003);
        }
        // 判断是否是正顺|火调|普通v3的场景，如果是正顺|火调|普通v3的场景，则发送到原来的系统进行计算
        if (!ObjectUtils.isEmpty(cameraDetail.getCompanyId())) {
            Company company = companyService.getById(cameraDetail.getCompanyId());
            if(ObjectUtils.isEmpty(company)){
                log.error("企业配置有误：" + cameraName);
                throw new BusinessException(CameraConstant.FAILURE_6003);
            }
            if (!ObjectUtils.isEmpty(company.getSceneVersion()) && company.getSceneVersion().equals("V3")) {
                //如果是app重新上传，需要解冻结
                if(Objects.nonNull(scenePro)){
                    sceneColdStorageService.unfreeze(scenePro.getNum(), "用户相机重新全量上传", scenePro.getDataSource());
                }

                callV3Service(preParams, api);
                return Boolean.TRUE;
            }
        }
//        else if (Objects.nonNull(scenePro) &&
//            scenePro.getSceneSource() != SceneSource.JG.code() &&
//            scenePro.getIsUpgrade() == CommonStatus.NO.code().intValue()){
//            callV3Service(preParams,api);
//            return Boolean.TRUE;
//        }
        return Boolean.FALSE;
    }

    public void callV3Service(String params,String api) throws Exception {
        log.info("params:{}", params);
        if(ObjectUtils.isEmpty(v3controlUrl)){
            log.error("未配置V3服务器!");
            throw new Exception("未配置V3服务器!");
        }
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        MultiValueMap<String,String> paramMap = new LinkedMultiValueMap();
        paramMap.add("params",params);
        HttpEntity<Object> formEntity = new HttpEntity<>(paramMap,headers);
        ResponseEntity<Result> responseEntity = restTemplate.postForEntity(v3controlUrl+api, formEntity, Result.class);
        if (responseEntity.getStatusCode().value() != HttpStatus.OK.value() || responseEntity.getBody().getCode() != ServerCode.SUCCESS.code()) {
            log.error("正顺场景请求V3服务器失败, params:{}, result:{}",params, JSON.toJSONString(responseEntity));
            throw new BusinessException(ErrorCode.SYSTEM_BUSY);
        }
        log.info("正顺场景请求V3服务器成功!");
    }

    @Override
    public ResultData turntableUploadSuccess(String params, User user) throws Exception {
        log.info("turntableUploadSuccess-params: " + params);
        String preParams = params;
        if (StringUtils.isEmpty(params)) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        params = params.replaceAll("%2B", "+");
        params = params.replaceAll(" ", "+");
        Base64 base64 = new Base64();
        String cipher = params;
        // 私钥解密过程
        byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile()),
                base64.decode(cipher));
        String restr = new String(res, "UTF-8");
        log.info("turntableUploadSuccess-params解密结果：" + restr);
        String[] strArr = restr.split(SPLICE);
        if (strArr.length != 3) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        String mac = strArr[0];
        String fileId = strArr[1];
        String folderName = redisUtil.get(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId));

        if(StringUtils.isEmpty(folderName)){
            SceneFileBuild fileBuild = findByFileId(fileId);
            if(ObjectUtils.isEmpty(fileBuild)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
            folderName = fileBuild.getUnicode();
            redisUtil.set(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId), folderName);
        }

        sceneUploadCountService.resetCountByUuid(folderName);

        //云目录
        StringBuilder prefixBuffer = new StringBuilder(mac).append(File.separator).append(fileId).append(File.separator).append(folderName).append(File.separator);

        String fileUploadedOpName = "fileUploadedOp.cam";
        String fileUploadedOpKey = new StringBuilder( ConstantFilePath.OSS_PREFIX).append(mac).append(File.separator).append(fileId).append(File.separator).append(folderName).append(File.separator).append(fileUploadedOpName).toString();
        if(fYunFileService.fileExist(fileUploadedOpKey)){
            Set<String> notExistsFiles = commonService.checkUploadFile(mac, fileId, folderName, fYunFileConfig.getFyunType());
            if(CollUtil.isNotEmpty(notExistsFiles)){
                log.error("文件缺失, unicode:{}, 缺失文件:{}", folderName, notExistsFiles);
                throw new BusinessException(ModelingControlRespCode.FILE_EMPTY.code(), ModelingControlRespCode.FILE_EMPTY.message());
            }
        }

        if(!fYunFileService.fileExist(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage")){
            log.error("data.fdage文件不存在");
            throw new BusinessException(CameraConstant.FAILURE_6009);
        }

        JSONObject fdageJson = JSONObject.parseObject(fYunFileService.getFileContent(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage"));
        if(ObjectUtils.isEmpty(fdageJson)){
            log.info("data.fdage文件为空");
            throw new BusinessException(CameraConstant.FAILURE_6009);
        }

        this.removeUpdateV4(ConstantFilePath.OSS_PREFIX + prefixBuffer + "data.fdage", fdageJson);

        String buildType = "V3";
        //13表示转台
        Long cameraType = 13L;

        //激光相机10 13
        int camType = fdageJson.getJSONObject("cam").getIntValue("type");
        log.info("camType:{}", camType);
        if(laserCamTypeList.contains(camType)){
            //激光转台
            cameraType = 14L;
        }

        // 判断是否是V3的场景
        ScenePro scenePro = sceneProService.getOne(
            new LambdaQueryWrapper<ScenePro>().like(ScenePro::getDataSource, "/".concat(fileId).concat("/")));

//        boolean callV3 = callV3(scenePro, preParams, fdageJson, "api/scene/file/turntableUploadSuccess");
//        if (callV3) return ResultData.ok();

        //激光场景校验是否能够计算
        this.checkJgCanBuild(scenePro);

        ScenePlusVO scenePlusVO = null;

        if (ObjectUtils.isEmpty(scenePro) || (!ObjectUtils.isEmpty(scenePro.getIsUpgrade()) && scenePro.getIsUpgrade() == 1)) {
            scenePlusVO = buildScene(fileId, prefixBuffer.toString(), fdageJson, buildType, cameraType, user);
        } else {
            scenePlusVO = buildV3Scene(scenePro,fileId, prefixBuffer.toString(), fdageJson, buildType, cameraType);
        }


        if(ObjectUtils.isEmpty(scenePlusVO) || scenePlusVO.getSceneStatus() == SceneStatus.EXCEED_SPACE.code()){
            return ResultData.ok();
        }
        // 通知激光场景系统开始构建场景
        if(cameraType.longValue() == 14 && fdageJson.getIntValue("location") != 7){
            ScenePlus scenePlus = scenePlusService.getScenePlusByNum(scenePlusVO.getNum());
            Long sceneUserId = scenePlus.getUserId();
            String userName = null;
            if(!ObjectUtils.isEmpty(sceneUserId)){
                userName = userService.getSSOUserByUserId(sceneUserId).getUserName();
            }
            //判断 是否为激光相机
            Camera camera = cameraService.getByChildName(mac);
            if(Objects.nonNull(scenePlus)){
                fdkkLaserService.saveScene(scenePlus,fdageJson,camera,userName,false, scenePlus.getPayStatus());
            }else{
                fdkkLaserService.saveScene(scenePro,fdageJson.getString("pwd"),camera,userName,false, scenePro.getPayStatus());
            }
        }

        return ResultData.ok();
    }

    public ScenePlusVO createScenePlus(String projectNum, Long cameraId, String cameraName, String phoneId, String sceneKey,
                                     String unicode, Long cameraType, int camType, String dataSource, String pic, Long userId, String userName,
                                     String algorithm, Integer location, Integer sceneShootCount, String sceneName,
                                     String sceneDec, Integer sceneType, String gps,Integer type,
                                     Integer resolution, String firmwareVersion, String url, String buildType,
                                     Long cooperationUser)throws Exception{

        ScenePlusVO scenePlusVO = new ScenePlusVO();
        ScenePlus scenePlus = new ScenePlus();
        ScenePlusExt scenePlusExt = new ScenePlusExt();
        scenePlusExt.setWebSite(url+projectNum);
        scenePlus.setCameraId(cameraId);
        scenePlus.setPhoneId(phoneId);
        scenePlus.setNum(projectNum);
        scenePlus.setSceneSource(SceneSource.BM.code());
        scenePlusExt.setDataSource(dataSource);
        scenePlusExt.setLocation(location);

        if(resolution == null || resolution.intValue() == 0){
            scenePlusExt.setSceneScheme(cameraType.intValue());
        }else {
            scenePlusExt.setSceneScheme(SceneScheme.BM.code());
        }
        if(cameraType == 6){
            scenePlusVO.setThreeCamType("yzl");
        }

        //转台相机用4k图
        if(cameraType.longValue() == 13){
            scenePlus.setSceneSource(SceneSource.ZT.code());
            scenePlusExt.setSceneScheme(SceneScheme.FOUR_K.code());
        }

        //激光相机
        if(cameraType.longValue() == 14){
            scenePlus.setSceneSource(SceneSource.JG.code());
            scenePlusExt.setSceneScheme(SceneScheme.FOUR_K.code());
            if(camType == CameraTypeEnum.LASER_SG.getType()){
                scenePlus.setSceneSource(SceneSource.SG.code());
            }
        }

        //全景看看场景用相机类型包括 看看 看见 深时 深光，所以这里做一个统一处理，为了让场景不在各平台中显示出来
        if(Objects.nonNull(location) && location == 7){
            scenePlus.setSceneSource(SceneSource.QJKK.code());
        }

        if(ModelKind.THREE_D_TILE.code().equals(modelKind)
                && CollUtil.isNotEmpty(sdTilesSceneSourceList)
                && sdTilesSceneSourceList.contains(scenePlus.getSceneSource())){
            scenePlusExt.setModelKind(modelKind);
        }

        //圆周率相机场景用3dtiles模型是
        if(cameraType == 6){
            scenePlusExt.setModelKind(modelKind);
        }

        if (pic != null && pic.length() > 5) {
            scenePlusExt.setThumb(pic);
        } else {
            scenePlusExt.setThumb(fYunFileConfig.getHost() + "/loading/thumb.jpg");
        }
        scenePlusExt.setThumb(scenePlusExt.getThumb().concat("?t=") + System.currentTimeMillis());
        scenePlus.setUserId(userId);

        if (sceneShootCount == null) {
            scenePlusExt.setShootCount(0);
        } else {
            scenePlusExt.setShootCount(sceneShootCount);
        }
        if (sceneName != null) {
            scenePlus.setTitle(sceneName);
        }
        if (sceneDec != null) {
            scenePlus.setDescription("<p>" + new String(sceneDec.getBytes("UTF-8")) + "</p>");
        }

        if (sceneType != null) {
            scenePlus.setSceneType(sceneType);
        }

        if (gps != null && !gps.trim().equals("")) {
            scenePlusExt.setGps(gps);
        }

        scenePlusExt.setAlgorithm(algorithm);
        if(!org.springframework.util.StringUtils.isEmpty(firmwareVersion)){
            scenePlusExt.setFirmwareVersion(firmwareVersion);
        }
        scenePlusExt.setBuildType(buildType);
        log.info("场景记录添加到数据库："+projectNum);
        //type=0为新生成场景，其余为重新计算场景

        if(camType == 5){//圆周率
            scenePlus.setThreeCamType("yzl");
        }

        SceneEditInfo sceneEditInfo = new SceneEditInfo();
        SceneEditInfoExt sceneEditInfoExt = new SceneEditInfoExt();
        SceneEditControls sceneEditControls = new SceneEditControls();
        if(type == 0){
            scenePlus.setSceneStatus(SceneStatus.wait.code());
            scenePlusService.save(scenePlus);
            scenePlusExt.setPlusId(scenePlus.getId());
            scenePlusExtService.save(scenePlusExt);
            sceneEditInfo.setTitle(scenePlus.getTitle());
            sceneEditInfo.setDescription(scenePlus.getDescription());
            sceneEditInfo.setScenePlusId(scenePlus.getId());

            if(StrUtil.isNotBlank(sceneKey)) {
                sceneEditInfo.setScenePassword(sceneKey);
                sceneEditControls.setShowLock((int) CommonStatus.YES.code());
            }
            sceneEditInfoService.save(sceneEditInfo);

            sceneEditInfoExt.setEditInfoId(sceneEditInfo.getId());
            sceneEditInfoExt.setScenePlusId(scenePlus.getId());
            sceneEditInfoExtService.save(sceneEditInfoExt);

            sceneEditControls.setEditInfoId(sceneEditInfo.getId());
            sceneEditControlsService.save(sceneEditControls);

            //新增场景时，同时新增场景协作信息
            if(cooperationUser != null){
                SceneCooperation sceneCooperationEntity = new SceneCooperation();
                sceneCooperationEntity.setNum(projectNum);
                sceneCooperationEntity.setUserId(cooperationUser);
                sceneCooperationService.save(sceneCooperationEntity);

                List<SceneResourceCamera> resourceCameraList = sceneResourceCameraService.findListByCameraId(cameraId);

                SceneResourceCooperation sceneResourceCooperation = null;
                if(resourceCameraList != null && resourceCameraList.size() > 0){
                    for (SceneResourceCamera sceneResourceCamera : resourceCameraList) {
                        sceneResourceCooperation = new SceneResourceCooperation();
                        sceneResourceCooperation.setSceneResourceId(sceneResourceCamera.getSceneResourceId());
                        sceneResourceCooperation.setSceneCooperationId(sceneCooperationEntity.getId());
                        sceneResourceCooperationService.save(sceneResourceCooperation);
                    }
                }
            }
        }else {
            ScenePlus oldScene = scenePlusService.getScenePlusByNum(projectNum);
            scenePlus.setId(oldScene.getId());
            scenePlus.setSceneStatus(SceneStatus.wait.code());
            scenePlus.setRecStatus(RecStatus.VALID.code());
            scenePlus.setPayStatus(PayStatus.NOT_PAY.code());
            scenePlus.setCreateTime(Calendar.getInstance().getTime());
            scenePlus.setBuildFailReason("");
            //只要开始常规场景上传计算，场景就不可以预览了
            scenePlus.setPreview(CommonStatus.NO.code());

            ScenePlusExt oldSceneExt = scenePlusExtService.getScenePlusExtByPlusId(oldScene.getId());
            scenePlusExt.setSpace(oldSceneExt.getSpace());
            scenePlusExt.setEcs(oldSceneExt.getEcs());
            scenePlusExt.setViewCount(oldSceneExt.getViewCount());
            if(sceneName!=null) {
                scenePlus.setTitle(sceneName);
            }
            if(sceneType!=null) {
                scenePlus.setSceneType(sceneType);
            }
            scenePlusService.updateById(scenePlus);
            scenePlusExtService.updateById(scenePlusExt);

            SceneEditInfo oldSceneEditInfo = sceneEditInfoService.getByScenePlusId(oldScene.getId());
            SceneEditInfoExt oldSceneEditeIinfoExt = sceneEditInfoExtService.getByEditInfoId(oldSceneEditInfo.getId());
            sceneEditInfo.setTitle(scenePlus.getTitle());
            sceneEditInfo.setDescription(scenePlus.getDescription());
            sceneEditInfo.setId(oldSceneEditInfo.getId());
            sceneEditInfo.setScenePlusId(scenePlus.getId());
            sceneEditInfo.setFloorLogoSize(100);
            sceneEditInfo.setRecStatus(RecStatus.VALID.code());
            sceneEditInfo.setFloorPublishVer(oldSceneEditInfo.getFloorEditVer() + 1);
            sceneEditInfo.setFloorEditVer(oldSceneEditInfo.getFloorEditVer() + 1);
            sceneEditInfo.setVersion(oldSceneEditInfo.getVersion() + 1);
            sceneEditInfoService.updateById(sceneEditInfo);

            if(Objects.nonNull(oldSceneEditeIinfoExt)){
                sceneEditInfoExt.setId(oldSceneEditeIinfoExt.getId());
            }
            sceneEditInfoExt.setEditInfoId(sceneEditInfo.getId());
            sceneEditInfoExt.setScenePlusId(scenePlus.getId());
            sceneEditInfoExtService.saveOrUpdate(sceneEditInfoExt);
        }

        BeanUtil.copyProperties(scenePlusExt, scenePlusVO);
        BeanUtil.copyProperties(scenePlus, scenePlusVO);

        return scenePlusVO;
    }

    public ScenePlusVO createScenePro(String projectNum, Long cameraId, String cameraName, String phoneId, String sceneKey,
                                      String unicode, Long cameraType, String fileId, String pic, Long userId, String userName,
                                      String algorithm, Integer sceneShootCount, String sceneName,String sceneDec,
                                      Integer sceneType, String gps,Integer resolution, String firmwareVersion, String buildType
    )throws Exception{


        ScenePro scene = sceneProService.getByNum(projectNum);
        SceneProEdit sceneEdit = sceneProEditService.getByProId(scene.getId());

        scene.setCameraId(cameraId);
        scene.setPhoneId(phoneId);
        scene.setNum(projectNum);
        scene.setSpace(0L);

        if (pic != null && pic.length() > 5) {
            scene.setThumb(pic);
        } else {
            scene.setThumb(ConstantUrl.DEFAULT_SCENE_PIC);
        }
        scene.setThumb(scene.getThumb().concat("?t=") + System.currentTimeMillis());

        if (!ObjectUtils.isEmpty(userName)) {
            scene.setUserId(userId);
        }

        if (sceneShootCount == null) {
            scene.setShootCount(0);
        } else {
            scene.setShootCount(sceneShootCount);
        }
        if (sceneName != null) {
            scene.setSceneName(sceneName);
        }
        if (sceneDec != null) {
            scene.setSceneDec("<p>" + new String(sceneDec.getBytes("UTF-8")) + "</p>");
        }

        if (sceneType != null) {
            scene.setSceneType(sceneType);
        }

        if (gps != null && !gps.trim().equals("")) {
            scene.setGps(gps);
        }

        scene.setAlgorithm(algorithm);
        if(!org.springframework.util.StringUtils.isEmpty(firmwareVersion)){
            scene.setFirmwareVersion(firmwareVersion);
        }
        scene.setBuildType(buildType);
        log.info("场景记录添加到数据库："+projectNum);

        scene.setStatus(0);
        scene.setPayStatus(0);
        scene.setRecStatus("A");
        scene.setCreateTime(new Date());
        if (sceneName != null) {
            scene.setSceneName(sceneName);
        }
        if (sceneType != null) {
            scene.setSceneType(sceneType);
        }
        sceneProService.updateById(scene);

        sceneEdit.setNeedKey(0);
        if (cameraType.longValue() != 14 && !ObjectUtils.isEmpty(sceneKey)) {
            sceneEdit.setNeedKey(1);
            sceneEdit.setSceneKey(sceneKey);
        }
        sceneEdit.setProId(scene.getId());
        sceneEdit.setMapVisi(1);
        sceneEdit.setTourVisi(1);
        sceneEdit.setVrVisi(1);
        sceneEdit.setCadImgVisi(1);
        sceneEdit.setPanoVisi(1);
        sceneEdit.setOverlay(null);
        sceneEdit.setM2dVisi(1);
        sceneEdit.setPlayData(null);
        sceneEdit.setFloorLogo("0");
        sceneEdit.setM3dVisi(1);
        sceneEdit.setJumpScene(false);
        sceneEdit.setMeasureVisi(0);
        sceneEdit.setFloorLogoSize(100);
        sceneEdit.setUpdateTime(new Date());
        sceneEdit.setRecStatus("A");
        sceneEdit.setFloorPublishVer(sceneEdit.getFloorEditVer() + 1);
        sceneEdit.setFloorEditVer(sceneEdit.getFloorEditVer() + 1);
        sceneEdit.setVersion(sceneEdit.getVersion() + 1);
        sceneEdit.setImagesVersion(sceneEdit.getImagesVersion() + 1);

        sceneProEditService.updateById(sceneEdit);


        JSONObject scenejson = JSONObject.parseObject(JSONObject.toJSONString(scene));
        scenejson.put("thumbImg", 0);
        scenejson.put("version", sceneEdit.getVersion());
        scenejson.put("floorLogo", 0);
        if(!ObjectUtils.isEmpty(sceneKey)){
            scenejson.put("sceneKey", sceneKey);
            scenejson.put("public", 1);
        }else{
            scenejson.put("sceneKey", "");
            scenejson.put("public", 0);
        }
        if(cameraType.longValue() < 4 || cameraType.longValue() == 5 || cameraType.longValue() == 6){
            scenejson.put("visions", 1);
        }else {
            scenejson.put("visions", 2);
        }
        scenejson.put("createTime", new DateTime(new Date()).toString("yyyy-MM-dd HH:mm"));

        scenejson.put("floorPublishVer", sceneEdit.getFloorPublishVer());
        scenejson.put("floorEditVer", sceneEdit.getFloorEditVer());
        scenejson.put("rulerVisi", sceneEdit.getRulerVisi());
        scenejson.put("entry", null);

        if(!org.springframework.util.StringUtils.isEmpty(sceneEdit.getHotsIds())){
            scenejson.put("hots", 1);
        }

        File file = new File(ConstantFilePath.SCENE_PATH+"data/data"+projectNum);
        if(!file.exists()||!file.isDirectory())
        {
            file.mkdirs();
        }
        FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data/data"+projectNum+File.separator+"scene.json", scenejson.toString());

        //生成二维码
        MatrixToImageWriterUtil.createQRCode(scene.getWebSite(), ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+projectNum+".png",false, null);
        MatrixToImageWriterUtil.createQRCode(scene.getWebSite() + "&lang=en", ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+projectNum+"_en.png",false, null);
        log.info("二维码生成完成");

        ScenePlusVO scenePlusVO = new ScenePlusVO();
        scenePlusVO.setSceneStatus(scene.getStatus());
        scenePlusVO.setThumb(scene.getThumb());
        scenePlusVO.setPayStatus(scene.getPayStatus());
        scenePlusVO.setId(scene.getId());
        scenePlusVO.setNum(scene.getNum());
        scenePlusVO.setWebSite(scene.getWebSite());
        scenePlusVO.setDataSource(scene.getDataSource());
        return scenePlusVO;
    }

    public BuildSceneCallMessage getBuildSceneMqMessage(String projectNum,
                                                        Long cameraType, String algorithm, JSONObject fdageJson,
                                                        String buildType, String dataSource) {
        BuildSceneCallMessage mqMsg = new BuildSceneCallMessage();
        mqMsg.setSceneNum(projectNum);
        mqMsg.setCameraType(String.valueOf(cameraType));
        mqMsg.setAlgorithm(algorithm);
        mqMsg.setResolution(String.valueOf(fdageJson.getInteger("resolution")));
        mqMsg.setBuildType(buildType);
        mqMsg.setPath(dataSource);
        mqMsg.setCreateTime(DateUtil.format(Calendar.getInstance().getTime(), DateExtUtil.dateStyle));
        Map<String, Object> ext = new HashMap<>();
        ext.put("location", fdageJson.getInteger("location"));
        mqMsg.setExt(ext);
        return mqMsg;
    }

    @Override
    public ResultData rebuildScene(String num,Boolean force,Boolean deleteExtras, String from) throws IOException {

        ScenePro scenePro = sceneProService.getByNum(num);
        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(num);

        //复制出来的场景不支持重算
        List<SceneCopyLog> sceneCopyLogs = sceneCopyLogService. listByNewNum(num);
        if(CollUtil.isNotEmpty(sceneCopyLogs)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5071);
        }

        //已删除原始资源的场景不支持重算
        Long cameraId = null;
        Date laseCallTime = null;
        ScenePlusExt scenePlusExt = null;
        if(Objects.nonNull(scenePlus)){
            scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
            laseCallTime = scenePlusExt.getAlgorithmTime();
            cameraId = scenePlus.getCameraId();
        }else{
            laseCallTime = scenePro.getCreateTime();
            cameraId = scenePro.getCameraId();
        }

//        //查询场景是否处于冻结状态，如果已冻结，不允许重算
//        SceneColdStorage sceneColdStorage = sceneColdStorageService.getOne(new LambdaQueryWrapper<SceneColdStorage>().eq(SceneColdStorage::getNum, num).eq(SceneColdStorage::getState, 1));
//        if(Objects.nonNull(sceneColdStorage)){
//            throw new BusinessException(ErrorCode.FAILURE_CODE_5074);
//        }
//
//        //查询最后一次计算时间后是否有删除过目录，如果有，则不支持重算
//        List<SceneCleanOrig> sceneCleanOrigs = sceneCleanOrigService.lisByNumAfterLastCall(num, laseCallTime);
//        if(CollUtil.isNotEmpty(sceneCleanOrigs)){
//            throw new BusinessException(ErrorCode.FAILURE_CODE_5072);
//        }


        //激光场景校验是否能够计算
        this.checkJgCanBuild(scenePro);

//        if(Objects.nonNull(scenePro) && (Objects.isNull(scenePro.getIsUpgrade())
//                || scenePro.getIsUpgrade() != CommonStatus.YES.code().intValue())){
//            return rebuildV3Scene(scenePro,num,force);
//        }

        if(Objects.isNull(scenePlus)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5005);
        }
        if (scenePlus.getSceneStatus() == 0 && (ObjectUtils.isEmpty(force) || !force)) {
            throw new BusinessException(ErrorCode.FAILURE_CODE_5033);
        }
        String path = scenePlusExt.getDataSource();
        Integer sceneSource = scenePlus.getSceneSource();
        String buildType = scenePlusExt.getBuildType();
        Integer sceneScheme = scenePlusExt.getSceneScheme();

        String dataFdageOssPath = ConstantFilePath.OSS_PREFIX+ path.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
                .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "") + "/data.fdage";

        JSONObject fdageData = JSONObject.parseObject(fYunFileService.getFileContent(dataFdageOssPath));
        if(ObjectUtils.isEmpty(fdageData)){
            log.error("data.fdage文件不存在");
            return ResultData.error(CameraConstant.FAILURE_6009.code(), CameraConstant.FAILURE_6009.message());
        }

        //重算的场景，先移除该场景对应的容量
        CameraDetail cameraDetail = cameraDetailService.getByCameraId(cameraId);
        if(CollUtil.isEmpty(laserCamTypeList) || !laserCamTypeList.contains(cameraDetail.getType())){
            try {
                scenePlusService.resetSpace(num);
            }catch (Exception e){
                log.error("重置容量失败", e);
            }
        }
        String statusJsonOssPath = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "status.json";
        JSONObject statusJson = JSONObject.parseObject(fYunFileService.getFileContent(String.format(UploadFilePath.DATA_VIEW_PATH, num) + "status.json"));
        if(ObjectUtils.isEmpty(statusJson)){
            statusJson = new JSONObject();
        }
        //临时将-2改成1，app还没完全更新
        statusJson.put("status", SceneStatus.wait.code());
        fYunFileService.uploadFile(statusJson.toJSONString().getBytes(StandardCharsets.UTF_8),statusJsonOssPath);

        Long cameraType = (long)sceneScheme == 3 ? 12 : (long)sceneScheme;
        //判断是否转台相机
        if(sceneSource == 3){
            cameraType = 13L;
        }
        if(sceneSource == 4 || sceneSource == 5){
            cameraType = 14L;
        }
        String threeCamType = scenePlus.getThreeCamType();
        if(StrUtil.isNotEmpty(threeCamType) && "yzl".equals(threeCamType)){
            cameraType = 6L;
        }
        BuildSceneCallMessage message = null;
        if(cameraType == 14){
            String userName = null;
            Long sceneUserId = scenePlus.getUserId();
            if (!ObjectUtils.isEmpty(sceneUserId)) {
                SSOUser user = userService.getSSOUserByUserId(sceneUserId);
                userName = user.getUserName();
            }
            Camera cameraEntity = cameraService.getById(scenePlus.getCameraId());
            if(Objects.isNull(scenePlusExt.getLocation()) || scenePlusExt.getLocation() != 7){
                fdkkLaserService.saveScene(scenePlus,null,cameraEntity,userName,true, scenePlus.getPayStatus());
            }
            message = this.getBuildSceneMqMessage(
                    num, cameraType, fdageData.getString("location") != null && "1".equals(fdageData.getString("location")) ? "sfm" : "slam",
                    fdageData, buildType, path);
        }else{
            message = this.getBuildSceneMqMessage(
                    num, cameraType, fdageData.getString("location") != null && "1".equals(fdageData.getString("location")) ? "sfm" : "slam",
                    fdageData, buildType, path);
            message.getExt().put("threeCamType", threeCamType);
        }
        if(deleteExtras){
            message.getExt().put("deleteExtras",deleteExtras);
        }
        if (force) {
            message.setRebuild("1");
        }

        if(Objects.nonNull(scenePlusExt.getLocation()) && scenePlusExt.getLocation() == 7){
            //发送到全景看看进行初始化
            JSONObject jsonObject = JSONObject.parseObject(fYunFileService.getFileContent(SceneUtil.getHomePath(scenePlusExt.getDataSource()) + "data.fdage"));
            intermitSceneService.sendMq(num, jsonObject, CommonSuccessStatus.WAITING.code());
            rabbitMqProducer.sendByWorkQueue(queueIntermitModelingPre, message);
        }else{
            rabbitMqProducer.sendByWorkQueue(queueModelingPre, message);
        }
        redisUtil.incr("modeling-count:" + num, 1);

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

        if(ModelKind.THREE_D_TILE.code().equals(modelKind)
                && CollUtil.isNotEmpty(sdTilesSceneSourceList)
                && sdTilesSceneSourceList.contains(scenePlus.getSceneSource())){
            scenePlusExt.setModelKind(modelKind);
        }
        scenePlusExt.setUpdateTime(new Date());
        scenePlusExtService.updateById(scenePlusExt);

        //记录日志表
        SceneRebuildLog rebuildLog = new SceneRebuildLog();
        rebuildLog.setNum(num);
        rebuildLog.setSource(from);
        sceneRebuildLogService.save(rebuildLog);

        return ResultData.ok();
    }

    /**
     * 由于算法不支持2022年三月份前的激光场景计算，这里需要校验是否是能计算，不能就退出重算
     * @return
     */
    private void checkJgCanBuild(ScenePro scenePro){

        if(Objects.isNull(scenePro) || StrUtil.isEmpty(scenePro.getDataSource()) || !SceneSource.JG.code().equals(scenePro.getSceneSource())){
            return;
        }
        cn.hutool.core.date.DateTime limitTime = DateExtUtil.parse(jgNotSupportBuildTime, DateExtUtil.dateStyle10);
        String dataSource = scenePro.getDataSource();
        String sceneDateTimeStr = dataSource.substring(dataSource.lastIndexOf("_") + 1).substring(0, 6);
        //如果截取的时间串是空的，无法判断时间，就退出，正常走计算逻辑
        if(StrUtil.isEmpty(sceneDateTimeStr)){
            return;
        }
        cn.hutool.core.date.DateTime sceneDateTime = null;
        try{
            sceneDateTime = DateExtUtil.parse(sceneDateTimeStr, DateExtUtil.dateStyle10);
            if(Objects.isNull(sceneDateTime)){
                return;
            }
        }catch (Exception e){
            //如果截取的时间串转换日期错误，无法判断时间，退出函数
            return;
        }

        if(sceneDateTime.before(limitTime)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5067);
        }

    }

//    public ResultData rebuildV3Scene(ScenePro scenePro,String num,Boolean force) throws IOException {
//
//                    JSONObject configJson = JSONObject.parseObject(FileUtils.readFile(configJsonPath));
//                    String folderName = configJson.getString("id");
//                    String customUserId = configJson.getString("customUserId");
//                    if(StrUtil.isBlank(folderName) || StrUtil.isBlank(snCode)){
//                        throw new RuntimeException("config.json 文件有误！");
//                    }
//
//                    // 检测是否有生成
//                    String fileId = getFileIdByFolderName(folderName);
//                    String subFolder = snCode.concat(File.separator).concat(fileId).concat(File.separator).concat(folderName);
//                    // 解压获取dataSource 并上传资源到OSS
//                    String dataSource = ConstantFilePath.BUILD_MODEL_PATH.concat(subFolder);
//                    log.info("dataSource 为：{}", dataSource);
//
//                    scenePre.setFileId(fileId);
//                    scenePre.setStatus(1);
//                    scenePre.setUpdateTime(new Date());
//                    scenePreService.updateById(scenePre);
//                    log.info("异步开始上传文件");
//                    // 上传oaas
//                    fYunFileService.uploadFileByCommand(dataPath, ConstantFilePath.OSS_PREFIX.concat(subFolder));
//
//                    //删除本地压缩包，防止补拍上传文件不一致
//                    FileUtil.del(parentPath);
//
//                    scenePre.setOssPath(ConstantFilePath.OSS_PREFIX.concat(subFolder));
//                    scenePre.setStatus(2);
//                    scenePre.setUpdateTime(new Date());
//                    scenePreService.updateById(scenePre);
//                    log.info("文件上传成功，开始通知计算");
//                    // 通知计算
//                    this.copyDataAndBuild(null, dataSource, "V4", null, customUserId);
//                    log.info("通知计算成功");
//
//                    scenePre.setStatus(3);
//                    scenePre.setUpdateTime(new Date());
//                    scenePreService.updateById(scenePre);
//                } catch (Exception e) {
//                    log.error("上传失败", e);
//                    scenePre.setStatus(CommonSuccessStatus.FAIL.code());
//                    scenePreService.updateById(scenePre);
//                }
//            }, executor);
//        }finally {
//            executor.shutdown();
//        }
//        return ResultData.ok();
//    }

    private String getFileIdByFolderName(String folderName) {
        // 检测是否有生成
        String fileId = redisUtil.get(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName));
        if (!org.springframework.util.ObjectUtils.isEmpty(fileId)) {
            return fileId;
        }

        SceneFileBuild sceneFileBuild = this.findByUnicode(folderName);
        if (sceneFileBuild != null) {
            fileId = sceneFileBuild.getFileId();
            redisUtil.set(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName), fileId, 2 * 24 * 60 * 60);
            return fileId;
        }

        // 加锁
        boolean lock = redisLockUtil.lock(String.format(RedisConstants.FOLDER_LOCK_BUILD, folderName), 120);
        if (!lock) {
            throw new BusinessException(ErrorCode.FAILURE_CODE_5052);
        }

        String dataSource =  scenePlusService.getDataSourceLikeUnicode("/" + folderName);

        if (!org.springframework.util.ObjectUtils.isEmpty(dataSource)) {
            log.info("从数据库中查到与 fileId:{} 匹配的路径为:{}", fileId, dataSource);
            int n = dataSource.split("/").length;
            if (n > 1) {
                fileId = dataSource.split("/")[n - 2];
            }
        }

        if (org.springframework.util.ObjectUtils.isEmpty(fileId)) {
            fileId = new SnowflakeIdGenerator(0, 0).nextId() + "";
            log.info("新生成build数据,{}", fileId);
        }

        sceneFileBuild = new SceneFileBuild();
        sceneFileBuild.setChildName(folderName.split("_")[0]);
        sceneFileBuild.setFileId(fileId);
        sceneFileBuild.setRecStatus("A");
        sceneFileBuild.setUnicode(folderName);
        sceneFileBuild.setCreateTime(new Date());
        this.save(sceneFileBuild);
        redisUtil.set(String.format(RedisConstants.FOLDER_FILEID_BUILD, folderName), fileId, 2 * 24 * 60 * 60);
        redisUtil.set(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId), folderName, 2 * 24 * 60 * 60);
        return fileId;
    }

    public ResultData copyDataAndBuild(String sourceBucet,String dataSource,String sceneVer,User user, String customUserId) throws Exception {
        if(!StringUtils.equals(sceneVer,"V3") && ! StringUtils.equals(sceneVer,"V4")){
            throw new BusinessException(ErrorCode.PARAM_FORMAT_ERROR.code(),"版本有误，请填写 V3 或者 V4");
        }

        String fYunPath = ConstantFilePath.OSS_PREFIX + dataSource.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
                .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "");
        if(!ObjectUtils.isEmpty(sourceBucet)){
            fYunFileService.copyFileBetweenBucket(sourceBucet,fYunPath,fYunFileConfig.getBucket(),fYunPath);
        }
        // 下载data.fdage
        JSONObject fdageData = JSONObject.parseObject(fYunFileService.getFileContent(fYunPath + "/data.fdage"));
        if(ObjectUtils.isEmpty(fdageData)){
            throw new BusinessException(ErrorCode.SYSTEM_ERROR.code(),"4dage 文件不存在");
        }
        String cameraName = fdageData.getJSONObject("cam").getString("uuid");
        Camera cameraEntity = cameraService.getByChildName(cameraName);
        if(cameraEntity ==  null){
            log.error("该相机不存在：" + cameraName);
            throw new BusinessException(ErrorCode.FAILURE_CODE_6003);
        }

        CameraDetail detailEntity = cameraDetailService.getByCameraId(cameraEntity.getId());
        if(detailEntity ==  null){
            log.error("该相机详情不存在：" + cameraName);
            throw new BusinessException(ErrorCode.FAILURE_CODE_6003);
        }

        Long cameraType = 11L;
        //判断是否转台相机
        if (detailEntity.getType() == 9) {
            cameraType = 13L;
        }

        if (CollUtil.isNotEmpty(laserCamTypeList) && laserCamTypeList.contains(detailEntity.getType())) {
            cameraType = 14L;
        }
        String sceneNum = scene3dNumService.generateSceneNum(detailEntity.getType());

        String icon = null;
        String imgViewPath = null;
        switch (sceneVer) {
            case "V3":
            case "V4":
                int rebuild = 0;
                ScenePlus scenePlus = scenePlusService.getByFileId(dataSource);
                if (!ObjectUtils.isEmpty(scenePlus)) {
                    log.info("该场景资源已存在，执行补拍逻辑！");
                    rebuild = 1;
                    sceneNum = scenePlus.getNum();
                }

                imgViewPath = String.format(UploadFilePath.IMG_VIEW_PATH, sceneNum);
                if(fdageData.containsKey("icon") && StringUtils.isNotEmpty(fdageData.getString("icon"))){
                    String ossPath = ConstantFilePath.OSS_PREFIX + dataSource.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
                            .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "");
                    fYunFileService.copyFileInBucket(ossPath + File.separator + fdageData.getString("icon"),imgViewPath + fdageData.getString("icon"));
                    icon = fYunFileConfig.getHost() + imgViewPath + fdageData.getString("icon");
                    log.info("上传icon成功....");
                }
                buildScenePost(dataSource, fdageData, "V3", cameraType, sceneNum, cameraEntity, detailEntity, rebuild, icon, user, customUserId, "zip");

                scenePlus = scenePlusService.getScenePlusByNum(sceneNum);
                fdkkLaserService.saveScene(scenePlus,fdageData,cameraEntity,user.getUserName(),rebuild == 1 ? true : false, scenePlus.getPayStatus());

                break;
        }
        Map<String,Object> result = new HashMap<>();
        result.put("code",sceneNum);
        return ResultData.ok(result);
    }

    private ScenePlusVO buildScenePost(String dataSource, JSONObject jsonObject, String buildType, long cameraType,
                                       String sceneNum, Camera camera, CameraDetail cameraDetail, int rebuild,String icon,User user, String customUserId, String uploadType) throws Exception {
        String imgViewPath = String.format(UploadFilePath.IMG_VIEW_PATH, sceneNum);

        JSONObject firmwareVersion = new JSONObject();
        if (!ObjectUtils.isEmpty(jsonObject.getString("camSoftwareVersion"))) {
            firmwareVersion.put("camSoftwareVersion", jsonObject.getString("camSoftwareVersion"));
        }

        if (!ObjectUtils.isEmpty(jsonObject.getString("version"))) {
            firmwareVersion.put("version", jsonObject.getString("version"));
        }

        String sceneUrl = "/" + sceneProNewUrl;

        //重算的场景，先移除该场景对应的容量
        if (rebuild == 1) {
            ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneNum);
            ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
            scenePlusExt.setSpace(0L);
            scenePlusExt.setUpdateTime(null);
            scenePlusExtService.updateById(scenePlusExt);
        } else {
            //上传log-main.png
            fYunFileService.uploadFile(ConstantFilePath.LOGO_PATH + "logo-main.png", imgViewPath + "logo-main.png");
            fYunFileService.uploadFile(ConstantFilePath.LOGO_PATH + "logo-main-en.png", imgViewPath + "logo-main-en.png");
        }
        String algorithm = jsonObject.getString("location") != null && "1".equals(jsonObject.getString("location")) ? "sfm" : "slam";
        String unicode = jsonObject.getString("creator") + "_" + jsonObject.getString("uuidtime");

        ScenePlusVO scenePlusVO = this.createScenePlus(sceneNum, camera.getId(), camera.getChildName(), jsonObject.getString("creator"),
                jsonObject.getString("pwd"), unicode, cameraType,jsonObject.getJSONObject("cam").getIntValue("type"), dataSource, icon, user.getId() , null, algorithm, jsonObject.getInteger("location"),
                jsonObject.getJSONArray("points").size(), jsonObject.getString("name"), jsonObject.getString("info"),
                jsonObject.getInteger("scenetype"), jsonObject.getString("gps"), rebuild,
                jsonObject.getInteger("resolution"), firmwareVersion.toString(), sceneUrl, buildType, cameraDetail.getCooperationUser());

        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneNum);
        scenePlus.setTaskId(jsonObject.getString("taskId"));
        scenePlus.setKNo(jsonObject.getString("kNo"));
        scenePlusService.updateById(scenePlus);
        ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
        boolean isObj = jsonObject.containsKey("exportMeshObj") && jsonObject.getIntValue("exportMeshObj") == 1;
        scenePlusExt.setIsObj(isObj ? CommonStatus.YES.code() : CommonStatus.NO.code());
        scenePlusExtService.updateById(scenePlusExt);

        BuildSceneCallMessage mqMessage = getBuildSceneMqMessage(sceneNum, cameraType, algorithm, jsonObject, buildType, scenePlusVO.getDataSource());

        if (cameraDetail.getCompanyId() != null) {
            Company company = companyService.getById(cameraDetail.getCompanyId());
            if (company != null && !ObjectUtils.isEmpty(company.getCalculateFlexibility()) && !company.getCalculateFlexibility()) {
                mqMessage.setFlexibility(-1);
            }
        }

        mqMessage.getExt().put("deleteExtras", true);
        mqMessage.getExt().put("customUserId", customUserId);
        mqMessage.getExt().put("gps", jsonObject.getString("gps"));
        mqMessage.getExt().put("threeCamType", scenePlusVO.getThreeCamType());

        if(uploadType.equals("single")){//场景上传模式（single-细小文件上传， zip-压缩包上传）
            OrigFileUploadBatch condition = new OrigFileUploadBatch();
            condition.setUuid(unicode);
            condition.setStatus(0);
            OrigFileUploadBatch origFileUploadBatch = origFileUploadBatchService.getByCondition(condition);
            origFileUploadBatch.setStatus(4);//修改为等待通知计算状态，由定时任务统一分配计算
            origFileUploadBatch.setMqContent(JSON.toJSONString(mqMessage));
            origFileUploadBatchService.updateById(origFileUploadBatch);
            redisUtil.del("single:upload:uuid:" + unicode);
        }else{
            rabbitMqProducer.sendByWorkQueue(queueModelingPre, mqMessage);
        }

        Map<String, Object> param = new HashMap<>();
        try {
            JyUser jyUser = scenePlusService.getJyUserByNum(sceneNum);
            param.put("event_type", "scene");
            param.put("event_content", "上传完毕");
            param.put("scene_num", sceneNum);
            param.put("event_time", new Date());
            if(Objects.nonNull(scenePlus)){
                param.put("scene_title", scenePlus.getTitle());
            }
            param.put("ryid", jyUser.getRyId());
            param.put("ryno", jyUser.getRyNo());
            param.put("nick_name", jyUser.getRyNickName());
            jmgaService.sendStatus(param);
        }catch (Exception e){
            log.info("推送事件失败,param:{}", param);
        }

        return scenePlusVO;
    }


    private void buildV3Scene2(String dataSource,JSONObject jsonObject,long cameraType,String sceneNum,Camera cameraEntity,CameraDetail detailEntity,String icon) throws Exception {

        String cameraName = jsonObject.getJSONObject("cam").getString("uuid");

        log.info("查询相机：" + cameraName);

        String userName = null;
        if(detailEntity.getUserId() != null){
            SSOUser user = userService.getSSOUserByUserId(detailEntity.getUserId());
            userName = user.getUserName();
        }

        JSONObject firmwareVersion = new JSONObject();
        if(jsonObject.containsKey("camSoftwareVersion") && StringUtils.isNotEmpty(jsonObject.getString("camSoftwareVersion"))){
            firmwareVersion.put("camSoftwareVersion", jsonObject.getString("camSoftwareVersion"));
        }

        if(jsonObject.containsKey("version") && StringUtils.isNotEmpty(jsonObject.getString("version"))){
            firmwareVersion.put("version", jsonObject.getString("version"));
        }


        String buildType = "V3";
        String sceneUrl = mainUrl + "/" + sceneProV3Url;

        boolean isObj = jsonObject.containsKey("exportMeshObj") && jsonObject.getIntValue("exportMeshObj") == 1;

        ScenePro scenePro = createScenePro(sceneNum, detailEntity.getCameraId(), jsonObject.getString("creator"),
                jsonObject.getString("pwd"),
                cameraType, dataSource, "", icon, detailEntity.getUserId(), userName,
                jsonObject.getString("location") != null && "1".equals(jsonObject.getString("location")) ? "sfm" : "slam",
                jsonObject.getJSONArray("points").size(), jsonObject.getString("name"), jsonObject.getString("info"),
                jsonObject.getInteger("scenetype"), jsonObject.getString("gps"), 0,
                jsonObject.getInteger("resolution"), firmwareVersion.toString(), sceneUrl, buildType,
                detailEntity.getCooperationUser(), isObj);

        // 通知激光场景系统开始构建场景
        if(cameraType == 14){
            scenePro.setStatus(0);
            fdkkLaserService.saveScene(scenePro, jsonObject.getString("pwd"), cameraEntity, userName, false, scenePro.getPayStatus());
        }

        BuildSceneCallMessage buildSceneMqMessage = this.getBuildSceneMqMessage(
                sceneNum, cameraType, jsonObject.getString("location") != null && "1".equals(jsonObject.getString("location")) ? "sfm" : "slam",
                jsonObject, buildType, dataSource);
        rabbitMqProducer.sendByWorkQueue(queueV3ModelingPre, buildSceneMqMessage);

    }

    public ScenePro createScenePro(String projectNum, Long cameraId, String phoneId, String sceneKey,
                                         Long cameraType, String dataSource, String imgsName,
                                         String pic, Long userId, String userName, String algorithm,
                                         Integer sceneShootCount, String sceneName, String sceneDec, Integer sceneType,
                                         String gps, Integer type, Integer resolution, String firmwareVersion, String url,
                                         String buildType, Long cooperationUser,Boolean isObj) throws Exception {
        ScenePro scene;
        SceneProEdit sceneEdit;
        if (type == 0) {
            scene = new ScenePro();
            sceneEdit = new SceneProEdit();
        } else {
            scene = sceneProService.getByNum(projectNum);
            sceneEdit = sceneProEditService.getByProId(scene.getId());
        }
        //先返回链接地址
        scene.setWebSite(url + projectNum);
        scene.setCameraId(cameraId);
        scene.setPhoneId(phoneId);
        scene.setNum(projectNum);

        scene.setSceneSource(1);
        scene.setDataSource(dataSource);
        if (cameraType.longValue() == 5 || cameraType.longValue() == 6) {
            //场景来源双目相机
            scene.setSceneSource(2);
        }

        if (resolution == null || resolution.intValue() == 0) {
            scene.setSceneScheme(cameraType.intValue());
        } else {
            scene.setSceneScheme(4);
        }

        //场景来源双目相机,sceneScheme为4,加载high,low图
        if (cameraType.longValue() == 5 || cameraType.longValue() == 6) {
            scene.setSceneScheme(4);
        }

        //转台相机用4k图
        if (cameraType.longValue() == 13) {
            scene.setSceneSource(3);
            scene.setSceneScheme(10);
        }

        //激光相机
        if (cameraType.longValue() == 14) {
            scene.setSceneSource(4);
            scene.setSceneScheme(10);
        }

        if (pic != null && pic.length() > 5) {
            scene.setThumb(pic);
        } else {
            scene.setThumb(ConstantUrl.DEFAULT_SCENE_PIC);
        }
        scene.setThumb(scene.getThumb().concat("?t=") + System.currentTimeMillis());
        if (!ObjectUtils.isEmpty(userName)) {
            scene.setUserId(userId);
        }

        if (sceneShootCount == null) {
            scene.setShootCount(0);
        } else {
            scene.setShootCount(sceneShootCount);
        }
        if (sceneName != null) {
            scene.setSceneName(sceneName);
        }
        if (sceneDec != null) {
            scene.setSceneDec("<p>" + new String(sceneDec.getBytes("UTF-8")) + "</p>");
        }

        if (sceneType != null) {
            scene.setSceneType(sceneType);
        }

        if (gps != null && !gps.trim().equals("")) {
            scene.setGps(gps);
        }

        scene.setAlgorithm(algorithm);
        scene.setFilesName(imgsName);
        if (!org.springframework.util.StringUtils.isEmpty(firmwareVersion)) {
            scene.setFirmwareVersion(firmwareVersion);
        }
        scene.setBuildType(buildType);
        log.info("场景记录添加到数据库：" + projectNum);
        //type=0为新生成场景，其余为重新计算场景


        if (type == 0) {
            scene.setIsObj(ObjectUtils.isEmpty(isObj) || !isObj ? 0 : 1);
            sceneProService.save(scene);

            sceneEdit = new SceneProEdit();
            sceneEdit.setNeedKey(0);

            if (sceneKey == null) {
                sceneKey = "";
            }
            sceneEdit.setSceneKey(sceneKey);
            if (!sceneKey.equals("")) {
                sceneEdit.setNeedKey(1);
            } else {
                sceneEdit.setNeedKey(0);
            }

            sceneEdit.setProId(scene.getId());
            sceneEdit.setMapVisi(1);
            sceneEdit.setTourVisi(1);
            sceneEdit.setVrVisi(1);
            sceneEdit.setRulerVisi(0);
            sceneEdit.setCadImgVisi(1);
            sceneEdit.setPanoVisi(1);
            sceneEdit.setM2dVisi(1);
            sceneEdit.setM3dVisi(1);
            sceneEdit.setMeasureVisi(0);
            sceneEdit.setFloorLogoSize(100);
            sceneEdit.setCreateTime(new Date());
            sceneProEditService.save(sceneEdit);

            //新增场景时，同时新增场景协作信息
            if (cooperationUser != null) {
                SceneCooperation sceneCooperationEntity = new SceneCooperation();
                sceneCooperationEntity.setNum(projectNum);
                sceneCooperationEntity.setUserId(cooperationUser);
                sceneCooperationService.save(sceneCooperationEntity);

                List<SceneResourceCamera> resourceCameraList = sceneResourceCameraService.findListByCameraId(cameraId);

                SceneResourceCooperation sceneResourceCooperationEntity = null;
                if (resourceCameraList != null && resourceCameraList.size() > 0) {
                    for (SceneResourceCamera sceneResourceCameraEntity : resourceCameraList) {
                        sceneResourceCooperationEntity = new SceneResourceCooperation();
                        sceneResourceCooperationEntity.setSceneResourceId(sceneResourceCameraEntity.getSceneResourceId());
                        sceneResourceCooperationEntity.setSceneCooperationId(sceneCooperationEntity.getId());
                        sceneResourceCooperationService.save(sceneResourceCooperationEntity);
                    }
                }
            }
        } else {
            scene.setStatus(0);
            scene.setPayStatus(0);
            scene.setRecStatus("A");
            scene.setCreateTime(new Date());
            if (sceneName != null) {
                scene.setSceneName(sceneName);
            }
            if (sceneType != null) {
                scene.setSceneType(sceneType);
            }
            sceneProService.updateById(scene);

            sceneEdit.setNeedKey(0);
            if (cameraType.longValue() != 14 && !ObjectUtils.isEmpty(sceneKey)) {
                sceneEdit.setNeedKey(1);
                sceneEdit.setSceneKey(sceneKey);
            }
            sceneEdit.setProId(scene.getId());
            sceneEdit.setMapVisi(1);
            sceneEdit.setTourVisi(1);
            sceneEdit.setVrVisi(1);
            sceneEdit.setCadImgVisi(1);
            sceneEdit.setPanoVisi(1);
            sceneEdit.setOverlay(null);
            sceneEdit.setM2dVisi(1);
            sceneEdit.setPlayData(null);
            sceneEdit.setFloorLogo("0");
            sceneEdit.setM3dVisi(1);
            sceneEdit.setJumpScene(false);
            sceneEdit.setMeasureVisi(0);
            sceneEdit.setFloorLogoSize(100);
            sceneEdit.setUpdateTime(new Date());
            sceneEdit.setRecStatus("A");
            sceneEdit.setFloorPublishVer(sceneEdit.getFloorEditVer() + 1);
            sceneEdit.setFloorEditVer(sceneEdit.getFloorEditVer() + 1);
            sceneEdit.setVersion(sceneEdit.getVersion() + 1);
            sceneEdit.setImagesVersion(sceneEdit.getImagesVersion() + 1);

            sceneProEditService.updateById(sceneEdit);


        }

        JSONObject scenejson = JSONObject.parseObject(JSONObject.toJSONString(scene));
        scenejson.put("thumbImg", 0);
        scenejson.put("version", sceneEdit.getVersion());
        scenejson.put("floorLogo", 0);
        if (!ObjectUtils.isEmpty(sceneKey)) {
            scenejson.put("sceneKey", sceneKey);
            scenejson.put("public", 1);
        } else {
            scenejson.put("sceneKey", "");
            scenejson.put("public", 0);
        }
        if (cameraType.longValue() < 4 || cameraType.longValue() == 5 || cameraType.longValue() == 6) {
            scenejson.put("visions", 1);
        } else {
            scenejson.put("visions", 2);
        }
        scenejson.put("createTime", new DateTime(new Date()).toString("yyyy-MM-dd HH:mm"));

        scenejson.put("floorPublishVer", sceneEdit.getFloorPublishVer());
        scenejson.put("floorEditVer", sceneEdit.getFloorEditVer());
        scenejson.put("rulerVisi", sceneEdit.getRulerVisi());
        scenejson.put("entry", null);

        if (!org.springframework.util.StringUtils.isEmpty(sceneEdit.getHotsIds())) {
            scenejson.put("hots", 1);
        }

        File file = new File(ConstantFilePath.SCENE_PATH + "data/data" + projectNum);
        if (!file.exists() || !file.isDirectory()) {
            file.mkdirs();
        }
        FileUtils.writeFile(ConstantFilePath.SCENE_PATH + "data/data" + projectNum + File.separator + "scene.json", scenejson.toString());

        return scene;
    }

    private ResultData rebuildV3SceneToMini(ScenePro scenePro){
        log.info("v3场景重算，请求v3服务器，url：{}",v3controlUrl+"api/scene/rebuildScene?num=" + scenePro.getNum());
        ResponseEntity<Result> responseEntity = restTemplate.getForEntity(v3controlUrl+"api/scene/rebuildScene?num=" + scenePro.getNum(), Result.class);
        if (responseEntity.getStatusCode().value() != HttpStatus.OK.value() || responseEntity.getBody().getCode() != ServerCode.SUCCESS.code()) {
            log.error("请求V3服务器重算场景失败, num:{}, result:{}",scenePro.getNum(), JSON.toJSONString(responseEntity));
            throw new BusinessException(ErrorCode.SYSTEM_BUSY);
        }
        log.info("v3场景重算，请求v3服务器，url：{}, result",v3controlUrl+"api/scene/rebuildScene?num=" + scenePro.getNum(), JSON.toJSONString(responseEntity));
        return ResultData.ok();
    }

    @Override
    public ResultData uploadFile(MultipartFile file, String params, String dir) throws Exception {

        log.info("upload-params: "+params);
        if (StringUtils.isEmpty(params)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        params = params.replaceAll("%2B", "+");
        Base64 base64 = new Base64();
        String cipher = params;
        // 私钥解密过程
        byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile()),
        base64.decode(cipher));
        String restr = new String(res, "UTF-8");
        log.info("upload-params解密结果：" + restr);
        String[] strArr = restr.split(SPLICE);
        if (strArr.length != 6) {
            throw new BusinessException(ErrorCode.PARAM_REQUIRED);
        }
        String mac = strArr[0];
        String fileId = strArr[1];
        String picNum = strArr[2];
        String md5 = strArr[3];
        String chunk = strArr[4];

        log.info("mac:{},fileId:{},picNum:{},md5:{},chunk:{}", mac, fileId, picNum, md5, chunk);

        ResultData result = null;
        if (file.isEmpty()){
            log.error("文件为空。");
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(),"文件为空。");
        }
        if (StringUtils.isEmpty(fileId)){
            log.error("文件Id为空。");
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(),"文件Id为空。");
        }
        if (picNum == null){
            log.error("照片数目为空。");
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(),"照片数目为空。");
        }
        if (StringUtils.isEmpty(mac)){
            log.error("mac为空。");
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(),"mac为空。");
        }
        if (StringUtils.isEmpty(md5)){
            log.error("md5为空。");
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(),"md5为空。");
        }
        long size = file.getSize();
        log.info("mac:{}, fileId:{}, picNum:{}, md5:{}, chunk:{}", mac, fileId, picNum, md5, chunk);
        chunk = chunk.split(SPLICE)[0];
        // 获取文件名
        String fileName = file.getOriginalFilename();
        log.info("上传的文件名为：" + fileName);
        // 获取文件的后缀名
        String folderName = redisUtil.get(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId));
        if(StringUtils.isEmpty(folderName)){
            SceneFileBuild fileBuild = findByFileId(fileId);
            if(ObjectUtils.isEmpty(fileBuild)){
                log.error("数据不正常，fileBuild没找到");
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
            folderName = fileBuild.getUnicode();
            redisUtil.set(String.format(RedisConstants.FILEID_FOLDER_BUILD, fileId), folderName,2 * 24 * 60 * 60);
        }
        // 1. 判断该文件是否已经上传过
        // 2. 如果已经上传过，判断MD5值和文件大小是否相等。如果相等，更新数据记录。如果不相等，删除该文件，重新上传。
        // 3. 如果未上传过，需要上传。
        String filePath = mac.concat(File.separator).concat(fileId).concat(File.separator).concat(folderName);

        String yunFilePath = LocalConstants.BASE_PATH.concat(fYunFileConfig.getBucket()).concat(File.separator).concat(ConstantFilePath.OSS_PREFIX)
                .concat(filePath).concat(File.separator).concat(dir).concat(fileName);
        log.info("yunFilePath:{}", yunFilePath);

        String key = RedisKeyExt.CAM_FILE_LIST.replace("@unicode@", folderName);
        String value = size + "_" + fileName;
        boolean needUpload = false;
        File yunFile = new File(yunFilePath);
        if (yunFile.exists()){
            String fileMD5 = FileMd5Util.getFileMD5(yunFile);
            if (md5.equals(fileMD5) && yunFile.length() == size){
                log.info("文件已存在，MD5和文件大小一致。");
                SceneFileUpload uploadEntity = sceneFileUploadService.findByFileIdAndChunk(fileId, Integer.valueOf(chunk));
                if (uploadEntity != null){
                    uploadEntity.setSize((int) size);
                    uploadEntity.setMd5(md5);
                    uploadEntity.setFilePath(yunFilePath);
                    uploadEntity.setFileSourceName(fileName);
                    uploadEntity.setUploadStatus(1);
                    sceneFileUploadService.updateById(uploadEntity);
                }else{
                    SceneFileUpload sceneFileUploadEntity = new SceneFileUpload();
                    sceneFileUploadEntity.setSize((int) size);
                    sceneFileUploadEntity.setMd5(md5);
                    sceneFileUploadEntity.setFilePath(yunFilePath.toString());
                    sceneFileUploadEntity.setFileSourceName(fileName);
                    sceneFileUploadEntity.setUploadStatus(1);
                    sceneFileUploadEntity.setFileId(fileId);
                    sceneFileUploadEntity.setChunk(Integer.valueOf(chunk));
                    sceneFileUploadService.save(sceneFileUploadEntity);
                }
                redisUtil.sSet(key, value);

                result = ResultData.ok();
            }else if (!md5.equals(fileMD5)) {
                log.warn("文件已上传，上传MD5："+md5+"，服务器MD5："+fileMD5+"。不一致。上传失败");
                FileUtils.delFile(yunFilePath.toString());
                needUpload = true;
            }else if (yunFile.length() != size){
                log.warn("文件已上传，文件大小不一致。上传失败");
                FileUtils.delFile(yunFilePath);
                needUpload = true;
            }
        }else {
            log.info("文件不存在，需要重新上传");
            needUpload = true;
        }

        // 4. 上传成功后，校验MD5和文件大小是否相等
        // 5. 如果相等，更新数据记录。如果不相等，返回上传失败结果。
        try {
            if (needUpload){
                fYunFileService.uploadFile(file.getInputStream(),ConstantFilePath.OSS_PREFIX.concat(filePath).concat(File.separator).concat(dir).concat(fileName));
                File uploadFile = new File(yunFilePath);
                String fileMD5 = FileMd5Util.getFileMD5(uploadFile);

                SceneFileUpload sceneFileUploadEntity = new SceneFileUpload();
                sceneFileUploadEntity.setSize((int) size);
                sceneFileUploadEntity.setMd5(md5);
                sceneFileUploadEntity.setFilePath(yunFilePath);
                sceneFileUploadEntity.setFileSourceName(fileName);
                sceneFileUploadEntity.setFileId(fileId);
                sceneFileUploadEntity.setChunk(Integer.valueOf(chunk));

                if (md5.equals(fileMD5) && uploadFile.length() == size){
                    log.info("文件已上传，MD5和文件大小一致。上传成功");
                    sceneFileUploadEntity.setUploadStatus(1);
                    sceneFileUploadService.save(sceneFileUploadEntity);
                    redisUtil.sSet(key, value);
                    result = ResultData.ok();
                }else if (!md5.equals(fileMD5)) {
                    log.error("文件已上传，上传MD5："+md5+"，服务器MD5："+fileMD5+"。不一致。上传失败");
                    sceneFileUploadEntity.setUploadStatus(-1);
                    sceneFileUploadService.save(sceneFileUploadEntity);
                    result = ResultData.error(ErrorCode.SYSTEM_ERROR,"上传失败, 请重新上传。");
                }else if (uploadFile.length() != size){
                    log.error("文件已上传，文件大小不一致。上传失败");
                    sceneFileUploadEntity.setUploadStatus(-1);
                    sceneFileUploadService.save(sceneFileUploadEntity);
                    result = ResultData.error(ErrorCode.SYSTEM_ERROR,"上传失败, 请重新上传。");
                }
            }
        }catch (IllegalStateException | IOException e) {
            log.error("上传失败, 请重新上传,md5:{},chunk:{}", md5, chunk);
            log.error("上传失败", e);
            result = ResultData.error(ErrorCode.SYSTEM_ERROR,"上传失败, 请重新上传。");
        }
        return result;
    }

    @Override
    public ResultData sendCallAlgorithm(SendCallAlgorithmParam param) throws Exception {
        log.info("sendCallAlgorithm 参数为：{}", JSONObject.toJSONString(param));

        String filePath = param.getFilepath();
        SendCallAlgorithmDetail detail = param.getDetails();
        String uploadType = detail.getUploadType();
        if(StrUtil.isNotEmpty(uploadType) && "log".equals(uploadType)){
            return ResultData.ok();
        }
        Integer fileChunkSum = detail.getFileChunkSum();
        String uuid = detail.getUuid();
        if(Objects.isNull(fileChunkSum) || StrUtil.isBlank(uuid)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(), "details参数中fileChunkSum和uuid不能为空");
        }

        String snCode = uuid.split("_")[0];
        String parentPath = sendCallAlgorithmPath.concat(uuid);
//        if(FileUtil.exist(parentPath)){
//            FileUtil.del(parentPath);
//        }
        Camera camera = cameraService.getByChildName(snCode);
        if(Objects.isNull(camera)){
            throw new BusinessException(ErrorCode.CAMERA_BIND_NO_EXIST.code(), "相机未入库");
        }

        String localFilePath = parentPath.concat(File.separator).concat(uuid).concat(".zip");
        try {
            String extName = FileUtil.extName(filePath);
            String subFilePath = parentPath.concat(File.separator).concat(uuid).concat(".").concat(extName);
            FileUtil.mkParentDirs(localFilePath);
            HttpUtil.downloadFile(filePath, subFilePath);
        }catch (Exception e){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5063.code(), "原始资源压缩包下载失败");
        }

        //检测压缩包分卷是否与detail中的总数一样
        List<String> fileNames = FileUtil.listFileNames(parentPath);
        if(fileNames.size() != fileChunkSum){
            return ResultData.ok("压缩包分卷不完整，请继续上传剩余的分卷");
        }

        if(!FileUtil.exist(localFilePath)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5063.code(), "zip压缩包不存在");
        }

        ScenePre scenePre = new ScenePre();
        scenePre.setZipPath(parentPath);
        scenePre.setCreateTime(new Date());
        scenePre.setUpdateTime(new Date());
        scenePre.setStatus(0);
        scenePreService.save(scenePre);

        // 异步解压资源文件上传
        ExecutorService executor = ThreadUtil.newSingleExecutor();
        try {
            CompletableFuture.runAsync(() -> {
                try {
                    log.info("开始异步解压文件");
                    ZipFile zipFile = new ZipFile(new File(localFilePath));
                    if (zipFile.isEncrypted()) {
                        zipFile.setPassword(ZipConstant.zipPassword);
                        zipFile.extractAll(parentPath);
                    } else {
                        ZipUtil.unzip(localFilePath, parentPath);
                    }

                    List<String> filePathList = FileUtils.list(new File(parentPath));
                    String configJsonPath = null;
                    for (String item : filePathList) {
                        if(!item.contains("config.json")){
                            continue;
                        }
                        configJsonPath = item;
                    }
                    String dataPath = FileUtil.getParent(configJsonPath, 1);

                    // 读取本地文件并校验文件
                    // 读取config.json
                    log.info("config.json路径:{}", configJsonPath);
                    if(!FileUtil.exist(configJsonPath)){
                        throw new RuntimeException("config.json 文件有误！");
                    }

                    JSONObject configJson = JSONObject.parseObject(FileUtils.readFile(configJsonPath));
                    String folderName = configJson.getString("id");
                    String customUserId = configJson.getString("customUserId");
                    String customUserName = configJson.getString("customUserName");
                    String customUserPwd = configJson.getString("customUserPwd");
                    if(StrUtil.isBlank(folderName) || StrUtil.isBlank(snCode)){
                        throw new RuntimeException("config.json 文件有误！");
                    }

                    // 检测是否有生成
                    String fileId = getFileIdByFolderName(folderName);
                    String subFolder = snCode.concat(File.separator).concat(fileId).concat(File.separator).concat(folderName);
                    // 解压获取dataSource 并上传资源到OSS
                    String dataSource = ConstantFilePath.BUILD_MODEL_PATH.concat(subFolder);
                    log.info("dataSource 为：{}", dataSource);

                    scenePre.setFileId(fileId);
                    scenePre.setStatus(1);
                    scenePre.setUpdateTime(new Date());
                    scenePreService.updateById(scenePre);
                    log.info("异步开始上传文件");
                    // 上传oaas
                    fYunFileService.uploadFileByCommand(dataPath, ConstantFilePath.OSS_PREFIX.concat(subFolder));

                    //删除本地压缩包，防止补拍上传文件不一致
                    FileUtil.del(parentPath);

                    scenePre.setOssPath(ConstantFilePath.OSS_PREFIX.concat(subFolder));
                    scenePre.setStatus(2);
                    scenePre.setUpdateTime(new Date());
                    scenePreService.updateById(scenePre);

                    log.info("开始判断人员是否存在，走注册用户逻辑");
                    log.info("userPasswordKey:{}", userPasswordKey);
                    log.info("userPasswordIv:{}", userPasswordIv);

                    //调注册用户接口
                    Map<String, Object> params = new HashMap<>();
                    params.put("ryId", customUserId);
                    params.put("ryNo", customUserName);
                    params.put("nickName", customUserName);
                    params.put("password", AesUtil.encryptCBC(customUserPwd, userPasswordKey, userPasswordIv, AesUtil.ALMODE_CBC_NOPADDING));
                    String url = fdServiceUrl.concat(ApiConstant.URL_ADD_UCENTER_USER);
                    myClient.post(url, params);
                    JyUser jyUser = jyUserService.getByRyId(customUserId);
                    User user = userService.getById(jyUser.getUserId());
                    if(Objects.isNull(jyUser)){
                        throw new RuntimeException("注册用户失败");
                    }

                    log.info("文件上传成功，开始通知计算");
                    // 通知计算
                    ResultData resultData = this.copyDataAndBuild(null, dataSource, "V4", user, customUserId);
                    log.info("通知计算成功");

                    scenePre.setStatus(3);
                    scenePre.setUpdateTime(new Date());
                    scenePreService.updateById(scenePre);
                } catch (Exception e) {
                    log.error("上传失败", e);
                    scenePre.setStatus(CommonSuccessStatus.FAIL.code());
                    scenePreService.updateById(scenePre);
                }
            }, executor);
        }finally {
            executor.shutdown();
        }
        return ResultData.ok();
    }

    public static void main(String[] args) throws Exception {
//        final String s = AesUtil.encryptCBC("Aa123456", "0000000856753656", "pwel781esd6wglxm", AesUtil.ALMODE_CBC_NOPADDING);
//        System.out.println(s);
//        System.out.println(UUID.fastUUID());

//        String test = "bpvt00017#1396877795149217792#";
//        String[] split = test.split("#");
//        System.out.println(split);
        String password = MD5.create().digestHex("Aa123456");
        System.out.println(password);
         password = MD5.create().digestHex16("Aa123456");
        System.out.println(password);

    }

    @Override
    public ResultData uploadFile(SendCallAlgorithmParam param) throws Exception {

        log.info("sendCallAlgorithm 参数为：{}", JSONObject.toJSONString(param));

        String filePath = param.getFilepath();
        if(StrUtil.isBlank(filePath)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(), "filePath不能为空");
        }
        SendCallAlgorithmDetail detail = param.getDetails();
        String uploadType = detail.getUploadType();
        if(StrUtil.isNotEmpty(uploadType) && "log".equals(uploadType)){
            return ResultData.ok();
        }
        String uuid = detail.getUuid();
        if(StrUtil.isBlank(uuid)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(), "uuid不能为空");
        }
        String fileName = detail.getFileName();
        if(StrUtil.isBlank(fileName)){
            throw new BusinessException(ErrorCode.PARAM_REQUIRED.code(), "fileName不能为空");
        }

        String callType = param.getDetails().getCallType();
        if(StrUtil.isNotEmpty(callType) && callType.equals("UPLOAD_WHILE_SHOOTING")){
            uploadShootingService.uploadFile(param);
            return ResultData.ok();
        }

        boolean lock = redisLockUtil.lock("lock:single:upload:uuid:" + uuid, uuid, 1);
        if(!lock){//如果拿不到锁，证明
            Thread.sleep(2000L);
        }

        String batchId = redisUtil.get("single:upload:uuid:" + uuid);
        if(StrUtil.isEmpty(batchId)){
            OrigFileUploadBatch condition = new OrigFileUploadBatch();
            condition.setUuid(uuid);
            condition.setStatus(0);
            OrigFileUploadBatch origFileUploadBatch = origFileUploadBatchService.getByCondition(condition);
            if(Objects.isNull(origFileUploadBatch)){
                batchId = redisUtil.get("single:upload:uuid:" + uuid);
                if(StrUtil.isEmpty(batchId)){
                    batchId = UUID.fastUUID().toString().replace("-", "");
                    redisUtil.set("single:upload:uuid:" + uuid, batchId);
                    origFileUploadBatch = new OrigFileUploadBatch();
                    origFileUploadBatch.setUuid(uuid);
                    origFileUploadBatch.setBatchId(batchId);
                    origFileUploadBatchService.save(origFileUploadBatch);
                }
            }
        }


        //插入上传明细表
        OrigFileUpload origFileUpload = new OrigFileUpload();
        origFileUpload.setFileUrl(filePath);
        origFileUpload.setFileName(fileName);
        origFileUpload.setBatchId(batchId);
        origFileUploadService.save(origFileUpload);

        if(lock){
            redisLockUtil.unlockLua("lock:single:upload:uuid:" + uuid, uuid);
        }

        if(fileName.equals("config.json")){
            HttpUtilExt.downloadFileAndCheck(filePath, sendCallAlgorithmPath.concat(uuid).concat("/config.json"), 300000);
        }
        if(fileName.equals("data.fdage")){
            HttpUtilExt.downloadFileAndCheck(filePath, sendCallAlgorithmPath.concat(uuid).concat("/data.fdage"), 300000);
        }
        if(fileName.equals("scene_up_data.txt")){
            HttpUtilExt.downloadFileAndCheck(filePath, sendCallAlgorithmPath.concat(uuid).concat("/scene_up_data.txt"), 300000);
        }

        return ResultData.ok();
    }

    @Override
    public ResultData noticeBuild(String uuid, Long bdId, String dataSource, String uploadType) throws Exception {
        log.info("通知计算,uuid:{} " + uuid);

        String sceneNum = null;
        SceneOrigBd sceneOrigBd = null;
        try {
            String[] uuidArr = uuid.split("_");
            String snCode = uuidArr[0];
            JSONObject fdageData = null;
            if(StrUtil.isNotEmpty(dataSource)){
                String homePath = SceneUtil.getHomePath(dataSource);
                fdageData = JSONObject.parseObject(fYunFileService.getFileContent(homePath + "data.fdage"));
            }else{
                fdageData = JSONObject.parseObject(FileUtils.readFile(sendCallAlgorithmPath.concat(uuid).concat("/data.fdage")));
            }
            int camType = fdageData.getJSONObject("cam").getIntValue("type");
            if(Objects.nonNull(bdId)){
                sceneOrigBd = sceneOrigBdService.getById(bdId);
                fdageData.put("taskId", sceneOrigBd.getTaskId());
                fdageData.put("kNo", sceneOrigBd.getKNo());
            }

            //相机入库
            String cameraInStoreUrl = fdServiceUrl + ApiConstant.URL_CAMERA_INSTORE;
            Map<String, Object> cameraInStoreParams = new HashMap<>();
            cameraInStoreParams.put("cameraType", camType);
            cameraInStoreParams.put("snCode", snCode);
            ResultData post = myClient.post(cameraInStoreUrl, cameraInStoreParams);
            log.info("---------cameraInStore result:{}-----------", post);

            Long cameraType = 13L;//默认为看见相机

            Camera camera = cameraService.getBySnCode(snCode);
            if(Objects.isNull(camera)){
                throw new BusinessException(ErrorCode.CAMERA_BIND_NO_EXIST.code(), "相机未入库");
            }
            CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
            if(Objects.isNull(cameraDetail)){
                throw new BusinessException(ErrorCode.CAMERA_BIND_NO_EXIST.code(), "相机未入库");
            }
            camType = cameraDetail.getType();
            if(camType == 10 || camType == 11){
                cameraType = 14L;//深时或者深光
            }else if(camType == 9){
                cameraType = 13L;//看见
            }else if(camType == 5){
                cameraType = 6L;//圆周率
            }else {
                cameraType = 10L;//看看
            }

            String ryId = null;
            String ryNo = null;
            String password = null;
            String phone = null;
            String idCard = null;
            String jyNo = null;
            String nickName = null;
            if(uploadType != null && uploadType.equals("single")){
                String fileId = this.getFileId(snCode, uuid);
                String subFolder = snCode.concat(File.separator).concat(fileId).concat(File.separator).concat(uuid);
                dataSource = ConstantFilePath.BUILD_MODEL_PATH.concat(subFolder);
                log.info("dataSource 为：{}", dataSource);

                JSONObject configJson = JSONObject.parseObject(FileUtils.readFile(sendCallAlgorithmPath.concat(uuid).concat("/config.json")));
                String folderName = configJson.getString("id");
                ryId = configJson.getString("customUserId");
                ryNo = configJson.getString("customUserName");
//                password =  AesUtil.encryptCBC(configJson.getString("customUserPwd"), userPasswordKey, userPasswordIv, AesUtil.ALMODE_CBC_NOPADDING);
                password = MD5.create().digestHex(configJson.getString("customUserPwd"));
                if(StrUtil.isBlank(folderName) || StrUtil.isBlank(snCode)){
                    throw new RuntimeException("config.json 文件有误！");
                }
            }else{
                ryId = sceneOrigBd.getRyId();
                ryNo = sceneOrigBd.getRyId();
                password = sceneOrigBd.getPassword();
                phone = sceneOrigBd.getRyPhone();
                idCard = sceneOrigBd.getRyCid();
                jyNo = sceneOrigBd.getRyNo();
                nickName = sceneOrigBd.getRyName();
            }
            //推送开始上传状态

            //调注册用户接口
            Map<String, Object> params = new HashMap<>();
            params.put("ryId", ryId);
            params.put("ryNo", ryNo);
            params.put("password", password);
            params.put("phone", phone);
            params.put("idCard", idCard);
            params.put("jyNo", jyNo);
            params.put("nickName", nickName);
            String url = fdServiceUrl.concat(ApiConstant.URL_ADD_UCENTER_USER);
            ResultData post1 = myClient.post(url, params);
            log.info("---------registerUser result:{}-----------", post1);
            JyUser jyUser = jyUserService.getByRyId(ryId);
            User user = userService.getById(jyUser.getUserId());
            if(Objects.isNull(jyUser)){
                throw new RuntimeException("注册用户失败");
            }

            int rebuild = 0;
            ScenePlus scenePlus = scenePlusService.getByFileId(dataSource);
            if (!ObjectUtils.isEmpty(scenePlus)) {
                log.info("该场景资源已存在，执行补拍逻辑！");
                rebuild = 1;
                sceneNum = scenePlus.getNum();
            }else{
                sceneNum = scene3dNumService.generateSceneNum(cameraDetail.getType());
            }

            buildScenePost(dataSource, fdageData, "V3", cameraType, sceneNum, camera, cameraDetail, rebuild, "", user, ryId, uploadType);

            scenePlus = scenePlusService.getScenePlusByNum(sceneNum);

            if(cameraType == 14){
                fdkkLaserService.saveScene(scenePlus,fdageData,camera,user.getUserName(),rebuild == 1 ? true : false, scenePlus.getPayStatus());
            }
            if(sceneOrigBd != null){
                sceneOrigBd.setStatus(CommonSuccessStatus.SUCCESS.code());
                sceneOrigBd.setUpdateTime(null);
                sceneOrigBdService.updateById(sceneOrigBd);
            }

        }catch (Exception e){
            if(sceneOrigBd != null){
                sceneOrigBd.setStatus(CommonSuccessStatus.FAIL.code());
                sceneOrigBd.setReason(ExceptionUtil.stacktraceToString(e,5000));
                sceneOrigBd.setUpdateTime(null);
                sceneOrigBdService.updateById(sceneOrigBd);
            }

            log.error("通知计算报错,uuid:{}", uuid, e);
            if(StrUtil.isNotEmpty(sceneNum)){

                jmgaService.updateSceneFailAndZipLog(sceneNum, "通知计算报错");

                String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, sceneNum);
                String preLogPath = buildLogPath + "noticeBuild-error-" + DateUtil.format(new Date(), DatePattern.PURE_DATETIME_PATTERN) + ".log";
                fYunFileService.uploadFile(ExceptionUtil.stacktraceToString(e).getBytes(StandardCharsets.UTF_8), preLogPath);

                Map<String, Object> param = new HashMap<>();
                try {
                    JyUser jyUser = scenePlusService.getJyUserByNum(sceneNum);
                    ScenePlus scenePlus = scenePlusService.getScenePlusByNum(sceneNum);
                    param.put("event_type", "scene");
                    param.put("event_content", "通知计算失败");
                    param.put("scene_num", sceneNum);
                    param.put("event_time", new Date());
                    if(Objects.nonNull(scenePlus)){
                        param.put("scene_title", scenePlus.getTitle());
                    }
                    param.put("ryid", jyUser.getRyId());
                    param.put("ryno", jyUser.getRyNo());
                    param.put("nick_name", jyUser.getRyNickName());
                    jmgaService.sendStatus(param);
                }catch (Exception ex){
                    log.info("推送事件失败,param:{}", param);
                }
            }

            throw e;
        }

        return ResultData.ok();
    }

    @Override
    public String getFileId(String snCode, String uuid){

        // 检测是否有生成
        String fileId = null;
        SceneFileBuild sceneFileBuild = this.findByUnicode(uuid);
        if(Objects.nonNull(sceneFileBuild)){
            fileId = sceneFileBuild.getFileId();
            return fileId;
        }

        fileId = new SnowflakeIdGenerator(0, 0).nextId() + "";
        log.info("新场景，fileid:{}", fileId);

        sceneFileBuild = new SceneFileBuild();
        sceneFileBuild.setChildName(snCode);
        sceneFileBuild.setFileId(fileId);
        sceneFileBuild.setRecStatus("A");
        sceneFileBuild.setUnicode(uuid);
        sceneFileBuild.setCreateTime(new Date());
        this.save(sceneFileBuild);

        return fileId;
    }


}