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){
        new Runnable() {
            @Override
            public void run() {
                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<>();
                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)){
                    filePathSet.add(mergeVideoUrl);
                }
                String mergeLocalName = VideoUtil.mergeVideo(filePathSet, 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());
    }


}