4dkankan-center-user/src/main/java/com/fdkankan/ucenter/service/impl/SceneProServiceImpl.java

package com.fdkankan.ucenter.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.SceneConstant;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.ucenter.common.PageInfo;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.common.util.JwtUtil;
import com.fdkankan.common.util.RandomUtil;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.image.MatrixToImageWriterUtil;
import com.fdkankan.model.constants.ConstantFilePath;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.ucenter.common.RedisKeyUtil;
import com.fdkankan.ucenter.constant.CameraConstant;
import com.fdkankan.ucenter.constant.LoginConstant;
import com.fdkankan.ucenter.entity.CameraDetail;
import com.fdkankan.ucenter.entity.Folder;
import com.fdkankan.ucenter.entity.SceneEditInfo;
import com.fdkankan.ucenter.entity.ScenePlus;
import com.fdkankan.ucenter.entity.ScenePlusExt;
import com.fdkankan.ucenter.entity.ScenePro;
import com.fdkankan.ucenter.entity.SceneProEdit;
import com.fdkankan.ucenter.entity.User;
import com.fdkankan.ucenter.httpClient.service.LaserService;
import com.fdkankan.ucenter.mapper.ISceneProMapper;
import com.fdkankan.ucenter.service.ICameraDetailService;
import com.fdkankan.ucenter.service.IFolderSceneService;
import com.fdkankan.ucenter.service.IFolderService;
import com.fdkankan.ucenter.service.IScene3dNumService;
import com.fdkankan.ucenter.service.ISceneCooperationService;
import com.fdkankan.ucenter.service.ISceneCopyLogService;
import com.fdkankan.ucenter.service.ISceneEditInfoService;
import com.fdkankan.ucenter.service.IScenePlusExtService;
import com.fdkankan.ucenter.service.IScenePlusService;
import com.fdkankan.ucenter.service.ISceneProEditService;
import com.fdkankan.ucenter.service.ISceneProService;
import com.fdkankan.ucenter.service.ISceneService;
import com.fdkankan.ucenter.service.IUserIncrementService;
import com.fdkankan.ucenter.service.IUserService;
import com.fdkankan.ucenter.util.DateUserUtil;
import com.fdkankan.ucenter.vo.request.SceneParam;
import com.fdkankan.ucenter.vo.response.GroupByCount;
import com.fdkankan.ucenter.vo.response.SceneInfoVo;
import com.fdkankan.ucenter.vo.response.SceneNumVo;
import com.fdkankan.ucenter.vo.response.SceneVo;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

/**
 * <p>
 * pro场景表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-07-04
 */
@Service
@Slf4j
public class SceneProServiceImpl extends ServiceImpl<ISceneProMapper, ScenePro> implements ISceneProService {

    @Autowired
    IUserService userService;
    @Autowired
    ISceneCooperationService sceneCooperationService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    LaserService fdkkLaserService;
    @Resource
    private FYunFileServiceInterface fYunFileService;
    @Autowired
    IUserIncrementService userIncrementService;
    @Autowired
    IScenePlusExtService scenePlusExtService;
    @Autowired
    ICameraDetailService cameraDetailService;
    @Autowired
    IFolderService folderService;
    @Autowired
    IFolderSceneService folderSceneService;
    @Autowired
    ISceneCopyLogService sceneCopyLogService;
    @Autowired
    IScene3dNumService scene3dNumService;
    @Autowired
    ISceneProEditService sceneProEditService;
    @Autowired
    ISceneEditInfoService sceneEditInfoService;
    @Autowired
    RedisUtil redisUtil;

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

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

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

    @Override
    public HashMap<String, SceneNumVo> findSceneNumber(String token) {
        User user = userService.getByUserName(JwtUtil.getUsername(token));
        SceneNumVo sceneNumVoKk = getSceneNumVoByType(Arrays.asList(1,2,12,13,14), user.getId());
        Integer oldNum = sceneService.getCountByUserId(user.getId());
        sceneNumVoKk.setSceneNum( oldNum + sceneNumVoKk.getSceneNum());
        sceneNumVoKk.setTotalNum(oldNum + sceneNumVoKk.getTotalNum());

        SceneNumVo sceneNumVoKj = getSceneNumVoByType(Collections.singletonList(3), user.getId());
        SceneNumVo sceneNumVoSS = fdkkLaserService.getLaserSceneNumByUser(token);
        HashMap<String, SceneNumVo> hashMap = new HashMap<>();
        hashMap.put("kk",sceneNumVoKk);
        hashMap.put("kJ",sceneNumVoKj);
        hashMap.put("SS",sceneNumVoSS);
        return hashMap;
    }

    private SceneNumVo getSceneNumVoByType(List<Integer> sceneSourceList, Long userId){
        SceneNumVo sceneNumVo = new SceneNumVo();
        LambdaQueryWrapper<ScenePro> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ScenePro::getUserId, userId);
        queryWrapper.in(ScenePro::getSceneSource, sceneSourceList);
        queryWrapper.eq(ScenePro::getIsUpgrade, 0);
        Integer sceneNum = Math.toIntExact(this.count(queryWrapper));

        Long count = scenePlusService.getCountByUserId(userId,sceneSourceList);
        sceneNumVo.setCooperationSceneNum(sceneCooperationService.getCooperationSceneNum(userId,sceneSourceList));
        sceneNumVo.setSceneNum(sceneNum + count);
        sceneNumVo.setTotalNum(sceneNumVo.getSceneNum() + sceneNumVo.getCooperationSceneNum());
        return sceneNumVo;
    }


    @Override
    public HashMap<Long,GroupByCount> findSceneNumByCameraIds(List<Long> cameraIdList) {
        HashMap<Long,GroupByCount> map = new HashMap<>();
        List<GroupByCount> result = this.getBaseMapper().findSceneProNumByCameraIds(cameraIdList);
        List<GroupByCount> result2 = this.getBaseMapper().findScenePlusNumByCameraIds(cameraIdList);
        result.forEach(entity ->map.put(entity.getId(),entity));
        for (GroupByCount groupByCount : result2) {
            if (map.get(groupByCount.getId()) != null) {
                Long totalCount = map.get(groupByCount.getId()).getCount() + groupByCount.getCount();
                String lastTime = DateUserUtil.getLastTime(map.get(groupByCount.getId()).getLastTime(), groupByCount.getLastTime());
                groupByCount.setCount(totalCount);
                groupByCount.setLastTime(lastTime);
            }
            map.put(groupByCount.getId(),groupByCount);
        }
        return map;
    }

    /**
     * @param payStatus -2 封存，为 1 解封
     */
    @Override
    public void lockOrUnLockBySpace(CameraDetail cameraDetail, Long cameraId, int payStatus) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<ScenePlus> plusWr = new LambdaQueryWrapper<>();
        Long count = 0L;
        if(payStatus == 1){ //解封，判断用户权益,用户会员权益无限容量
            count = userIncrementService.getValidCountByCameraId(cameraId);
            wrapper.orderByAsc(ScenePro::getCreateTime);
            plusWr.orderByAsc(ScenePlus::getCreateTime);
        }else {
            wrapper.orderByDesc(ScenePro::getCreateTime);
            plusWr.orderByDesc(ScenePlus::getCreateTime);
        }
        wrapper.eq(ScenePro::getCameraId,cameraId)
                .eq(ScenePro::getPayStatus,payStatus)
                .eq(ScenePro::getSceneScheme,4)
                .eq(ScenePro::getIsUpgrade,0);
        plusWr.eq(ScenePlus::getCameraId,cameraId)
                .eq(ScenePlus::getPayStatus,payStatus);
        List<ScenePro> list = this.list(wrapper);
        List<ScenePlus> plusList = scenePlusService.list(plusWr);
        Long beyondSpace = Math.abs(cameraDetail.getUsedSpace() - cameraDetail.getTotalSpace());
        Long accumulateSpace = 0L;
        List<Long> lockedIds = new ArrayList<>();
        if(payStatus == 1){
            getScenePlusLockedIds(lockedIds,plusList,count,beyondSpace,accumulateSpace);
            getSceneLockedIds(lockedIds,list,count,beyondSpace,accumulateSpace);
        }else {
            getSceneLockedIds(lockedIds,list,count,beyondSpace,accumulateSpace);
            getScenePlusLockedIds(lockedIds,plusList,count,beyondSpace,accumulateSpace);
        }

        lockOrUnLockScenes(lockedIds,payStatus);
    }
    private void getSceneLockedIds(List<Long> lockedIds ,List<ScenePro> list,Long count,Long beyondSpace,Long accumulateSpace){
        if (list != null && list.size() > 0){
            for (ScenePro scenePro : list){
                accumulateSpace += scenePro.getSpace();
                if (count ==0 && accumulateSpace.compareTo(beyondSpace) > 0){
                    break;
                }
                lockedIds.add(scenePro.getId());
            }
        }
    }
    private void getScenePlusLockedIds(List<Long> lockedIds ,List<ScenePlus> list,Long count,Long beyondSpace,Long accumulateSpace){
        if (list != null && list.size() > 0){
            List<Long> plusIds = list.parallelStream().map(ScenePlus::getId).collect(Collectors.toList());
            HashMap<Long, ScenePlusExt> byPlusIds = scenePlusExtService.getByPlusIds(plusIds);
            for (ScenePlus scenePlus : list){
                ScenePlusExt scenePlusExt = byPlusIds.get(scenePlus.getId());
                accumulateSpace += scenePlusExt.getSpace();
                if (count ==0 && accumulateSpace.compareTo(beyondSpace) > 0){
                    break;
                }
                lockedIds.add(scenePlus.getId());
            }
        }
    }


    // payStatus 为 -2 封存，为 1 解封
    private void lockOrUnLockScenes(List<Long> lockedIds,Integer payStatus) {
        if (lockedIds == null || lockedIds.size() == 0){
            return;
        }
        LambdaUpdateWrapper<ScenePro> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(ScenePro::getPayStatus,payStatus)
                .eq(ScenePro::getIsUpgrade,0)
                .in(ScenePro::getId,lockedIds);
        this.update(updateWrapper);

        LambdaUpdateWrapper<ScenePlus> updatePlusWrapper = new LambdaUpdateWrapper<>();
        updatePlusWrapper.set(ScenePlus::getPayStatus,payStatus)
                .in(ScenePlus::getId,lockedIds);
        scenePlusService.update(updatePlusWrapper);

    }


    @Override
    public List<ScenePro> getListByCameraId(Long cameraId) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePro::getCameraId,cameraId)
                .eq(ScenePro::getIsUpgrade,0);
        return this.list(wrapper);
    }

    @Override
    public void bindOrUnCamera(List<Long> cameraIds, Long userId) {
        LambdaUpdateWrapper<ScenePro> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(ScenePro::getCameraId,cameraIds)
                .eq(ScenePro::getIsUpgrade,0)
                .set(ScenePro::getUserId,userId);
        this.update(wrapper);
    }

    @Override
    public List<ScenePro> getListByCameraIds(List<Long> cameraIds) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getCameraId,cameraIds)
                .eq(ScenePro::getIsUpgrade,0);
        return this.list(wrapper);
    }

    @Override
    public List<ScenePro> getListByNums(List<String> numList) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getNum,numList)
                .eq(ScenePro::getIsUpgrade,0);
        return this.list(wrapper);
    }
    @Override
    public Long getCountByUserId(Long userId, List<Integer> resourceList) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePro::getUserId,userId);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        wrapper.in(ScenePro::getSceneSource,resourceList);
        return this.count(wrapper);
    }

    @Override
    public Long getCountByUserId(Long id, Integer cameraType) {
        return this.getBaseMapper().getCountByUserId(id,cameraType);
    }

    @Override
    public void deleteByIds(List<Long> sceneIds) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getId,sceneIds)
                .eq(ScenePro::getIsUpgrade,0);
        List<ScenePro> proList = this.list(wrapper);

        LambdaQueryWrapper<ScenePlus> plusWr = new LambdaQueryWrapper<>();
        plusWr.in(ScenePlus::getId,sceneIds);
        List<ScenePlus> plusList = scenePlusService.list(plusWr);

        this.deleteByList(proList,plusList);
    }

    @Override
    public JSONObject newList(SceneParam param, String username) {
        User user = userService.getByUserName(username);
        param.setSourceList(getSceneSource(param.getSceneSource()));
        param.setUserId(user.getId());
        Page<SceneVo> sceneVoPage = getBaseMapper().pageListAndFolder(new Page<>(param.getPageNum(),param.getPageSize()),param);

        List<SceneVo> folderList = sceneVoPage.getRecords().parallelStream().filter(entity -> entity.getIsFolder() == 1).collect(Collectors.toList());
        Integer folderNum = 0;
        if(folderList.size() >0){
            List<Long> folderIds = folderList.parallelStream().map(SceneVo::getId).collect(Collectors.toList());
            List<Folder> allFolderIds = folderService.getAllFolderIds(folderIds);
            folderNum = allFolderIds.size();
            HashMap<Long,Long> map = folderSceneService.getGroupByFolderIds(allFolderIds);
            for (SceneVo vo : sceneVoPage.getRecords()) {
                if(vo.getIsFolder() == 1){
                    Long sceneNum = map.get(vo.getId()) == null ? 0L : map.get(vo.getId());
                    vo.setSceneNum(sceneNum);
                    vo.setCreateTimeStr(vo.getCreateTime());
                }
            }
            List<SceneVo> records = sceneVoPage.getRecords();
            List<SceneVo> sceneList = records.parallelStream().filter(entity -> entity.getIsFolder() == 0).collect(Collectors.toList());
            folderList.addAll(sceneList);
            sceneVoPage.setRecords(folderList);
        }
        //设置协作者信息
        if(sceneVoPage.getRecords().size() >0){
            List<String> numList = sceneVoPage.getRecords().parallelStream().map(SceneVo::getNum).collect(Collectors.toList());
            HashMap<String,User> cooMap = sceneCooperationService.getByNumList(numList);
            for (SceneVo vo : sceneVoPage.getRecords()) {
                if (StringUtils.isNotBlank(vo.getNum())) {
                    User userVo = cooMap.get(vo.getNum());
                    if (userVo != null) {
                        vo.setCooperationUserId(userVo.getId().toString());
                        vo.setCooperationUserName(userVo.getUserName());
                    }
                }
            }
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("pageInfo",PageInfo.PageInfo(sceneVoPage));
        jsonObject.put("sceneNum",sceneVoPage.getTotal() - folderNum);
        return jsonObject;
    }

    public List<String> getSceneSource(String sceneSource){
        List<String> sceneSourceList ;
        switch (sceneSource){
            case "1" : sceneSourceList = Arrays.asList("1","2","12","13","14"); break;  //四维看看
            case "3" : sceneSourceList = Collections.singletonList("3"); break;//四维看见
            default:
                if(sceneSource.contains(",")){
                    sceneSource = sceneSource + ",12,13,14";
                    sceneSourceList = Arrays.asList(sceneSource.split(","));
                    break;
                }
                sceneSourceList = Collections.singletonList(sceneSource);break;
        }
        return sceneSourceList;
    }

    @Override
    public void copyScene(String sceneNum,String userName) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BusinessException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }
        ScenePro scenePro = this.getByNum(sceneNum);
        ScenePlus scenePlus = scenePlusService.getByNum(sceneNum);
        if((scenePro == null || scenePro.getCameraId() == null ) && (scenePlus== null || scenePlus.getCameraId() == null)){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        Long cameraId = scenePro == null ? scenePlus.getCameraId() : scenePro.getCameraId();
        Long userId = scenePro == null ? scenePlus.getUserId() :scenePro.getUserId();
        // 判断是否有绑定会员权益
        Long count = userIncrementService.getValidCountByCameraId(cameraId);
        if(count <= 0){
            throw new BusinessException(LoginConstant.FAILURE_CODE_3030, LoginConstant.FAILURE_MSG_3030);
        }
        if(userId == null){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5013, SceneConstant.FAILURE_MSG_5013);
        }
        //只能复制自己的场景
        User user = userService.getByUserName(userName);
        if(user == null || !user.getId().equals(userId) ){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5013, SceneConstant.FAILURE_MSG_5013);
        }
        CameraDetail detailEntity = cameraDetailService.getByCameraId(cameraId);
        if(detailEntity == null){
            throw new BusinessException(CameraConstant.FAILURE_CODE_6029, CameraConstant.FAILURE_MSG_6029);
        }
        String newNum = scene3dNumService.generateSceneNum(detailEntity.getType());

        if(scenePro !=null){        //v3场景复制
            this.copyV3Scene(scenePro,newNum,detailEntity);
        }
        if(scenePlus != null){      //v4场景复制
            scenePlusService.copyV4Scene(scenePlus,newNum,detailEntity);
        }

    }

    @Override
    public ScenePro getByNum(String sceneNum) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePro::getNum,sceneNum);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        List<ScenePro> list = this.list(wrapper);
        if(list!= null && list.size() >0){
            return list.get(0);
        }
        return null;
    }


    @Override
    public void copyV3Scene(ScenePro oldScene,String newNum,CameraDetail cameraDetail) throws Exception {
        SceneProEdit oldEditScene = sceneProEditService.getByProId(oldScene.getId());

        String oldNum = oldScene.getNum();
        //复制数据库数据
        oldScene.setId(null);
        oldScene.setStatus(0);
        oldScene.setNum(newNum);
        oldScene.setSceneName(oldScene.getSceneName().concat("(copy)"));
        oldScene.setWebSite(oldScene.getWebSite().replace(oldScene.getNum(), newNum));
        oldScene.setThumb(oldScene.getThumb().replace(oldScene.getNum(), newNum));
        oldScene.setVideos(oldScene.getVideos().replace(oldNum,newNum));
        oldScene.setViewCount(0);
        String preDataSource = oldScene.getDataSource();
        oldScene.setDataSource(this.setDataSource(preDataSource,oldScene.getSceneSource()));

        this.save(oldScene);

        sceneCopyLogService.saveByNum(oldNum,newNum,oldScene.getUserId());
        //复制完成更新相机容量
        cameraDetail.setUsedSpace(cameraDetail.getUsedSpace() + oldScene.getSpace());
        cameraDetailService.updateById(cameraDetail);

        oldEditScene.setId(null);
        oldEditScene.setProId(oldScene.getId());
        oldEditScene.setScreencapVoiceSrc(oldEditScene.getScreencapVoiceSrc() == null ? null : oldEditScene.getScreencapVoiceSrc().replace(oldNum, newNum));
        oldEditScene.setScreencapVoiceSound(oldEditScene.getScreencapVoiceSound() == null ? null : oldEditScene.getScreencapVoiceSound().replace(oldNum, newNum));
        oldEditScene.setScreencapVoiceSoundsync(oldEditScene.getScreencapVoiceSoundsync() == null ? null : oldEditScene.getScreencapVoiceSoundsync().replace(oldNum, newNum));
        oldEditScene.setPlayData(oldEditScene.getPlayData() == null ? null : oldEditScene.getPlayData().replace(oldNum, newNum));
        oldEditScene.setScreencapThumb(oldEditScene.getScreencapThumb() == null ? null : oldEditScene.getScreencapThumb().replace(oldNum, newNum));
        oldEditScene.setFloorPlanPng(oldEditScene.getFloorPlanPng() == null ? null : oldEditScene.getFloorPlanPng().replace(oldNum, newNum));
        sceneProEditService.save(oldEditScene);

        this.setQrCode(oldScene.getBuildType(), oldScene.getNum());
        CompletableFuture.runAsync(() -> {
            try {
                log.info("开始复制场景-{}", new Date());

                //oss复制计算结果资源
                this.copyOssSource("v3",oldNum,newNum);
                this.copyLocalSource(oldNum,newNum);

                updateSceneJson("v3",oldScene.getVideos(),newNum,oldScene.getSceneName(),oldScene.getWebSite(),oldScene.getThumb(),oldScene.getId());
                //上传资源到oss
                uploadNewSceneToOss(newNum);
                oldScene.setStatus(-2);
                this.updateById(oldScene);
                log.info("复制场景结束-{}", new Date());
            } catch (Exception e) {
                log.error("复制场景异常", e);
            }
        });

    }

    @Override
    public String setDataSource(String preDataSource,Integer sceneSource) throws Exception {
        String datasourceFix;
        String newDataSource;
        // 判断场景是否拷贝过
        ScenePro entity;
        do{
            datasourceFix = RandomUtil.generateShortUuid();
            entity = this.findByFileId(preDataSource.concat(datasourceFix));
        }while(!ObjectUtils.isEmpty(entity));
        newDataSource =  datasourceFix.concat(datasourceFix);

        //oss复制源文件
        String buildModelPath = ConstantFilePath.BUILD_MODEL_PATH;
        if(sceneSource.equals(4)){
            buildModelPath = ConstantFilePath.BUILD_MODEL_LASER_PATH;
        }
        CreateObjUtil.ossUtilCp(ConstantFilePath.OSS_PREFIX +newDataSource.replace(buildModelPath, "")+"/", newDataSource);

        List<String> urlList = new ArrayList<>();
        FileUtils.readfilePath(newDataSource, urlList);
        Map<String,String> fileMap = new HashMap<>();
        for(String url : urlList){
            fileMap.put(url, ConstantFilePath.OSS_PREFIX + url.replace(buildModelPath, ""));
        }
        fYunFileService.uploadMulFiles(fileMap);

        FileUtils.delAllFile(newDataSource);

        FileUtils.copyFolderAllFiles(preDataSource+"/",newDataSource+"/", true);
        return datasourceFix.concat(datasourceFix);
    }

    @Override
    public void copyOssSource(String type ,String sceneNum, String newNum) throws Exception {
        List<String > copyList = new ArrayList<>();
        if(type.equals("v3")){
            copyList.add("images/images" + sceneNum);
            copyList.add("data/data" + sceneNum);
            copyList.add("voice/voice" + sceneNum);
            copyList.add("video/video"+ sceneNum);
        }else if(type.equals("v4")){
            String oldEditPath = String.format(UploadFilePath.EDIT_PATH, sceneNum);
            String oldViewPath = String.format(UploadFilePath.VIEW_PATH, sceneNum);
            copyList.add(oldEditPath);
            copyList.add(oldViewPath);
        }
        for (String sourcePath : copyList) {
            fYunFileService.copyFileInBucket(sourcePath,sourcePath.replaceAll(sceneNum,newNum));
        }
    }

    @Override
    public void copyLocalSource(String sceneNum, String newNum) throws Exception {
        FileUtils.copyDirectiory(ConstantFilePath.SCENE_PATH +"images/images" + sceneNum,ConstantFilePath.SCENE_PATH +"images/images" + newNum);
        FileUtils.copyDirectiory(ConstantFilePath.SCENE_PATH +"data/data" + sceneNum,ConstantFilePath.SCENE_PATH +"data/data" + newNum);
        reloadFile(ConstantFilePath.SCENE_PATH + "data/data" + newNum + "/link-scene.json",sceneNum, newNum);
        reloadFile(ConstantFilePath.SCENE_PATH + "data/data" + newNum + "/hot.json",sceneNum, newNum);
        FileUtils.copyDirectiory(ConstantFilePath.SCENE_PATH +"voice/voice" + sceneNum,ConstantFilePath.SCENE_PATH +"voice/voice" + newNum);
        FileUtils.copyDirectiory(ConstantFilePath.SCENE_PATH +"video/video" + sceneNum,ConstantFilePath.SCENE_PATH +"video/video" + newNum);
    }

    private void reloadFile(String filePath,String sceneNum, String newNum) throws Exception {
        // 修改link-scene.json
        String content = FileUtils.readFile(filePath);
        if (!ObjectUtils.isEmpty(content)) {
            content = content.replaceAll(sceneNum, newNum);
            FileUtils.writeFile(filePath,content);
        }
    }


    /**
     * 上传新场景资源到oss
     * @param newNum
     */
    private void uploadNewSceneToOss(String newNum) {
        Map<String, String> map = new HashMap();
        List<String> urlList = new ArrayList<>();
        FileUtils.readfilePath(ConstantFilePath.SCENE_PATH + "images/images" + newNum, urlList);
        FileUtils.readfilePath(ConstantFilePath.SCENE_PATH + "data/data" + newNum, urlList);
        FileUtils.readfilePath(ConstantFilePath.SCENE_PATH + "voice/voice" + newNum, urlList);
        FileUtils.readfilePath(ConstantFilePath.SCENE_PATH + "video/video" + newNum, urlList);
        for(String url : urlList){
            map.put(url, url.replace(ConstantFilePath.SCENE_PATH, ""));
        }
        fYunFileService.uploadMulFiles(map);
    }

    @Override
    public void updateSceneJson(String type,String videos,String newNum,String sceneName,String webSite,String thumb,Long id) throws Exception {
        //更新video
        HashMap<String,Object> map = new HashMap<>();
        map.put("videos",videos);
        map.put("sceneName",sceneName);
        map.put("webSite",webSite);
        map.put("thumb",thumb);
        map.put("num",newNum);
        map.put("id",id);
        String uploadPath ;
        String localPath = ConstantFilePath.SCENE_PATH + "data/data" + newNum + File.separator + "scene.json";
        if(type.equals("v3")){
            uploadPath = localPath.replace(ConstantFilePath.SCENE_PATH, "");
        }else {
            uploadPath =localPath.replace(ConstantFilePath.SCENE_V4_PATH, "");
        }
        FileUtils.writeJsonFile(localPath, map);
        if(type.equals("v4")){
            fYunFileService.uploadFile(localPath,uploadPath);
        }
    }

    @Override
    public void delete(String sceneNum) {
        if(StringUtils.isEmpty(sceneNum)){
            throw  new BusinessException(LoginConstant.FAILURE_CODE_3001,LoginConstant.FAILURE_MSG_3001);
        }
        String[] nums = sceneNum.split(",");
        List<String> numList = Arrays.asList(nums);
        List<ScenePro> proList = this.getListByNums(numList);
        List<ScenePlus> plusList = scenePlusService.getListByNums(numList);
        this.deleteByList(proList,plusList);
    }

    @Override
    public void deleteByList(List<ScenePro> proList,List<ScenePlus> plusList) {
        HashMap<Long ,Long >cameraMap = new HashMap<>();
        if(proList.size() >0){
            for (ScenePro scenePro : proList) {
                cameraMap.merge(scenePro.getCameraId(), scenePro.getSpace(), Long::sum);
            }
            List<Long> proIds = proList.parallelStream().map(ScenePro::getId).collect(Collectors.toList());
            this.removeByIds(proIds);
        }
        if(plusList.size() >0){
            List<Long> plusIds = plusList.parallelStream().map(ScenePlus::getId).collect(Collectors.toList());
            HashMap<Long, ScenePlusExt> plusMap = scenePlusExtService.getByPlusIds(plusIds);

            for (ScenePlus scenePlus : plusList) {
                cameraMap.merge(scenePlus.getCameraId(), plusMap.get(scenePlus.getId()).getSpace(), Long::sum);
            }
            scenePlusService.removeByIds(plusIds);
        }
        //恢复相机使用容量
        if(cameraMap.size() >0){
            cameraDetailService.addUsedSpace(cameraMap);
        }
    }

    @Override
    public ScenePro getByUnicode(String unicode) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(ScenePro::getDataSource,unicode);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        wrapper.orderByDesc(ScenePro::getCreateTime);
        List<ScenePro> list = this.list(wrapper);
        if(list !=null && list.size() >0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public SceneInfoVo getInfo(String num) {
        if(StringUtils.isEmpty(num)){
            throw new BusinessException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }
        ScenePro scenePro = this.getByNum(num);
        ScenePlus scenePlus = scenePlusService.getByNum(num);
        if(scenePro == null && scenePlus == null){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        if(scenePro!=null && scenePro.getStatus() != 1 && scenePro.getStatus() != -2){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5033, SceneConstant.FAILURE_MSG_5033);
        }
        if(scenePlus!=null && scenePlus.getSceneStatus() != 1 && scenePlus.getSceneStatus() != -2){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5033, SceneConstant.FAILURE_MSG_5033);
        }
        if(scenePro!=null && scenePro.getPayStatus() != 1){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5034, SceneConstant.FAILURE_MSG_5034);
        }
        if(scenePlus!=null && scenePlus.getPayStatus() != 1){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5034, SceneConstant.FAILURE_MSG_5034);
        }
        SceneInfoVo infoVo = new SceneInfoVo();
        if(scenePro!=null){
            SceneProEdit sceneProEdit = sceneProEditService.getByProId(scenePro.getId());
            if(sceneProEdit !=null){
                BeanUtils.copyProperties(sceneProEdit, infoVo);
            }
            BeanUtils.copyProperties(scenePro,infoVo);
            if(StringUtils.isNotEmpty(scenePro.getGps())){
                infoVo.setGps(JSONObject.parseObject(scenePro.getGps()).toJSONString());
            }
            infoVo.setSceneKey("");
            infoVo.setCreateDate(DateUserUtil.getDate(scenePro.getCreateTime()).getTime());
        }else {
            SceneEditInfo sceneEditInfo = sceneEditInfoService.getByScenePlusId(scenePlus.getId());
            ScenePlusExt scenePlusExt = scenePlusExtService.getByPlusId(scenePlus.getId());
            if(sceneEditInfo != null){
                BeanUtils.copyProperties(sceneEditInfo,infoVo);
            }
            if(scenePlusExt !=null){
                BeanUtils.copyProperties(scenePlusExt,infoVo);
            }
            BeanUtils.copyProperties(scenePlus,infoVo);
            infoVo.setSceneName(scenePlus.getTitle());
            infoVo.setStatus(scenePlus.getSceneStatus());
        }


        if(StringUtils.isNotEmpty(infoVo.getEntry())){
            infoVo.setEntry(JSONObject.parseObject(infoVo.getEntry()).toJSONString());
        }
        if(StringUtils.isEmpty(infoVo.getSceneKey())){
            infoVo.setIsPublic(0);
        }else {
            infoVo.setIsPublic(1);
        }

        //查询是否有随心装场景
        if(num.contains("vr-")){
            infoVo.setVrNum(null);
            infoVo.setVideosUser(null);
            infoVo.setBgMusicName(null);
            infoVo.setBgMusic(null);
        }
        this.updateViewCount(num);
        return infoVo;
    }

    @Override
    public void updateViewCount(String num) {
        String redisKey = RedisKeyUtil.SCENE_VIEW_COUNT + num;
        if(!redisUtil.hasKey(redisKey)){
            Integer count = null;
            ScenePro pro = this.getByNum(num);
            if(pro !=null){
                count = pro.getViewCount();
            }else {
                ScenePlus plus = scenePlusService.getByNum(num);
                if(plus !=null){
                    ScenePlusExt scenePlusExt = scenePlusExtService.getByPlusId(plus.getId());
                    count = scenePlusExt.getViewCount();
                }
            }
            if(count !=null){
                redisUtil.set(redisKey,String.valueOf(count));
            }
        }
        if(redisUtil.hasKey(redisKey)){
            redisUtil.incr(redisKey,1);
        }
    }

    @Override
    public void updateDbViewCount(String num, String count) {
        LambdaUpdateWrapper<ScenePro> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(ScenePro::getNum,num);
        wrapper.set(ScenePro::getViewCount,count);
        this.update(wrapper);

        ScenePlus plus = scenePlusService.getByNum(num);
        if(plus !=null){
            LambdaUpdateWrapper<ScenePlusExt> exWr = new LambdaUpdateWrapper<>();
            exWr.eq(ScenePlusExt::getPlusId,plus.getId())
                    .set(ScenePlusExt::getViewCount,count);
            scenePlusExtService.update(exWr);
        }
    }

    @Override
    public ScenePro findByFileId(String fileId) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(ScenePro::getDataSource,fileId);
        List<ScenePro> list = this.list(wrapper);
        if(list !=null && list.size() >0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public void setQrCode(String buildType,String num) throws Exception {
        String basePath = mainUrl;
        if("V2".equals(buildType)){
            basePath += sceneProUrl;
        }
        if("V3".equals(buildType)){
            basePath += sceneProNewUrl;
        }
        MatrixToImageWriterUtil.createQRCode(basePath + num, ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+num+".png", false,null);
        MatrixToImageWriterUtil.createQRCode(basePath + num + "&lang=en", ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+num+"_en.png", false,null);

    }
}