package com.fdkankan.fusion.service.impl;

import cn.hutool.core.io.FileUtil;
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.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.common.FilePath;
import com.fdkankan.fusion.common.util.RedisKeyUtil;
import com.fdkankan.fusion.common.util.UploadToOssUtil;
import com.fdkankan.fusion.common.util.VideoUtil;
import com.fdkankan.fusion.entity.CaseEntity;
import com.fdkankan.fusion.entity.CaseVideoFolder;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.entity.CaseVideo;
import com.fdkankan.fusion.mapper.ICaseVideoMapper;
import com.fdkankan.fusion.service.ICaseService;
import com.fdkankan.fusion.service.ICaseVideoFolderService;
import com.fdkankan.fusion.service.ICaseVideoService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.redis.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author
 * @since 2022-07-29
 */
@Service
public class CaseVideoServiceImpl extends ServiceImpl<ICaseVideoMapper, CaseVideo> implements ICaseVideoService {


    @Autowired
    UploadToOssUtil uploadToOssUtil;
    @Autowired
    ICaseVideoFolderService videoFolderService;
    @Autowired
    ICaseService caseService;
    @Autowired
    UploadService uploadService;
    @Value("${upload.query-path}")
    private String queryPath;
    @Autowired
    RedisUtil redisUtil;

    @Override
    public List<CaseVideo> getAllList(Integer folderId) {
        if(folderId == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        QueryWrapper<CaseVideo> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(CaseVideo::getFolderId,folderId);
        wrapper.lambda().orderByAsc(CaseVideo::getSort);
        wrapper.lambda().orderByAsc(CaseVideo::getCreateTime);
        return this.list(wrapper);
    }

    @Override
    public CaseVideoFolder uploadAddVideo(MultipartFile[] files, Integer folderId,Integer caseId) throws IOException {
        if(files.length <=0 || caseId == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        CaseEntity caseEntity = caseService.getById(caseId);
        if(caseEntity == null){
            throw new BusinessException(ResultCode.CASE_NOT_EXIST);
        }
        CaseVideoFolder videoFolder = videoFolderService.getByIdIfNotNew(folderId,caseId);
        if(videoFolder == null){
            throw new BusinessException(ResultCode.FOLDER_NOT_EXIST);
        }

        runThread(files,videoFolder,this);
        return videoFolder;
    }

    private void runThread(MultipartFile[] files,CaseVideoFolder videoFolder,ICaseVideoService caseVideoService){
        ((Runnable) () -> {
            String mergeVideoUrl = null;
            if (StringUtils.isNotBlank(videoFolder.getVideoMergeUrl())) {
                mergeVideoUrl = videoFolder.getVideoMergeUrl().replace(queryPath, "/home/");
                uploadToOssUtil.downFormAli(videoFolder.getVideoMergeUrl().replace(queryPath, ""), mergeVideoUrl);
                uploadService.deleteOssUrl(videoFolder.getVideoMergeUrl());
            }
            if (StringUtils.isNotBlank(videoFolder.getVideoMergeUrl())) {
                uploadService.deleteOssUrl(videoFolder.getVideoFolderCover());
            }
            caseVideoService.deleteByFolderId(videoFolder.getVideoFolderId());
            redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "10");
            //替换文件夹中文件
            List<CaseVideo> videoList = new ArrayList<>();
            Integer sort = 1;
            LinkedHashSet<String> filePathSet = new LinkedHashSet<>();
            LinkedHashSet<String> filePathSetAll = new LinkedHashSet<>();
            for (MultipartFile file : files) {
                String ossPath = uploadService.uploadFile(file, true, String.format(FilePath.VIDEO_OSS_PATH, videoFolder.getVideoFolderId()) + "/", filePathSet);
                String suffixName = ossPath.substring(ossPath.lastIndexOf("."));

                CaseVideo caseVideo = new CaseVideo();
                caseVideo.setFolderId(videoFolder.getVideoFolderId());
                caseVideo.setVideoPath(ossPath);
                caseVideo.setVideoName(file.getName());
                caseVideo.setVideoCover(ossPath.replace(suffixName, ".jpg"));
                caseVideo.setSort(sort);
                videoList.add(caseVideo);
                sort++;
            }
            caseVideoService.saveBatch(videoList);
            if (videoList.size() <= 0) {
                return;
            }

            redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "20");
            if (StringUtils.isNotBlank(mergeVideoUrl)) {
                filePathSetAll.add(mergeVideoUrl);
            }
            filePathSetAll.addAll(filePathSet);
            String mergeLocalName = VideoUtil.mergeVideo(filePathSetAll, FilePath.VIDEO_LOCAL_PATH);
            redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "30");
            if (mergeLocalName == null) {
                updateCaseVideoStatus(videoFolder.getVideoFolderId(), -1);
                redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "-1");
                return;
            }
            String mergeLocalPath = FilePath.VIDEO_LOCAL_PATH + "/" + mergeLocalName;
            String ossKey = String.format(FilePath.VIDEO_OSS_PATH, videoFolder.getVideoFolderId()) + "/" + mergeLocalName;

            String mergeLocalPathImg = FilePath.VIDEO_LOCAL_PATH + "/" + mergeLocalName.replace(".mp4", ".jpg");
            String ossKeyImg = String.format(FilePath.VIDEO_OSS_PATH, videoFolder.getVideoFolderId()) + "/" + mergeLocalName.replace(".mp4", ".jpg");
            uploadToOssUtil.uploadOss(mergeLocalPath, ossKey);
            uploadToOssUtil.uploadOss(mergeLocalPathImg, ossKeyImg);
            if (!uploadToOssUtil.existKey(ossKey) && !uploadToOssUtil.existKey(ossKeyImg)) {
                updateCaseVideoStatus(videoFolder.getVideoFolderId(), -1);
                redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "-1");
                return;
            }
            redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "70");

            videoFolder.setVideoMergeUrl(queryPath + ossKey);
            videoFolder.setVideoFolderCover(queryPath + ossKeyImg);
            videoFolderService.updateById(videoFolder);
            //  FileUtil.del(FilePath.VIDEO_LOCAL_PATH);
            redisUtil.set(RedisKeyUtil.mergerVideoKey + videoFolder.getVideoFolderId(), "100");
            updateCaseVideoStatus(videoFolder.getVideoFolderId(), 1);
        }).run();
    }

    private void updateCaseVideoStatus(Integer folderId, Integer status) {
        LambdaUpdateWrapper<CaseVideo> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(CaseVideo::getFolderId,folderId)
                .set(CaseVideo::getUploadStatus,status);
        this.update(wrapper);
        LambdaUpdateWrapper<CaseVideoFolder> wrapperFolder = new LambdaUpdateWrapper<>();
        wrapperFolder.eq(CaseVideoFolder::getVideoFolderId,folderId)
                .set(CaseVideoFolder::getUploadStatus,status);
        videoFolderService.update(wrapperFolder);
    }

    @Override
    public String uploadAddVideoProgress(Integer folderId) {
        String redisKey = RedisKeyUtil.mergerVideoKey+folderId;
        if(redisUtil.hasKey(redisKey)){
            return redisUtil.get(redisKey);
        }
        return "0";
    }

    @Override
    public void deleteByFolderId(Integer videoFolderId) {
        LambdaQueryWrapper<CaseVideo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CaseVideo::getFolderId,videoFolderId);
        List<CaseVideo> list = this.list(wrapper);
        if(list.size() <=0){
            return;
        }
        for (CaseVideo caseVideo : list) {
            this.delete(caseVideo.getVideoId());
        }
    }

    @Override
    public void delete(Integer videoId) {
        CaseVideo caseVideo = this.getById(videoId);
        this.removeById(videoId);
        uploadService.deleteOssUrl(caseVideo.getVideoPath());
        uploadService.deleteOssUrl(caseVideo.getVideoCover());
    }


}