/**
 * 20241029 ©WANGKANG 1686617586@qq.com
 */

package com.taais.biz.service.impl;

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.DecimalFormat;
import java.util.*;

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson2.JSON;
import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryWrapper;
import com.taais.biz.constant.BizConstant;
import com.taais.biz.domain.*;
import com.taais.biz.domain.vo.AlgorithmConfigTrackVo;
import com.taais.biz.domain.vo.AlgorithmModelTrackVo;
import com.taais.biz.domain.vo.StartTaskConfig;
import com.taais.biz.utils.ZipUtils;
import com.taais.common.core.config.TaaisConfig;
import com.taais.common.core.constant.Constants;
import com.taais.common.core.core.domain.CommonResult;
import com.taais.common.core.utils.MapstructUtils;
import com.taais.common.core.utils.StringUtils;
import com.taais.common.orm.core.page.PageQuery;
import com.taais.common.core.core.page.PageResult;
import com.taais.common.orm.core.service.impl.BaseServiceImpl;
import com.taais.system.domain.vo.SysOssVo;
import com.taais.system.service.ISysOssService;
import jakarta.annotation.Resource;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.taais.biz.mapper.TrackSequenceMapper;
import com.taais.biz.domain.bo.TrackSequenceBo;
import com.taais.biz.domain.vo.TrackSequenceVo;
import com.taais.biz.service.ITrackSequenceService;

import static com.taais.biz.constant.BizConstant.VideoStatus.NOT_START;
import static com.taais.biz.domain.table.TrackSequenceTableDef.TRACK_SEQUENCE;
import static com.taais.biz.service.impl.TargetDetectionServiceImpl.getFileSize;
import static com.taais.biz.service.impl.TargetDetectionServiceImpl.port;
import static com.taais.biz.service.impl.ToInfraredServiceImpl.readLogContent;
import static com.taais.biz.service.impl.VideoStableServiceImpl.*;
import static com.taais.biz.service.impl.VideoStableServiceImpl.makeDir;

/**
 * 注视轨迹序列Service业务层处理
 *
 * @author wangkang
 * 2024-09-22
 */
@Service
public class TrackSequenceServiceImpl extends BaseServiceImpl<TrackSequenceMapper, TrackSequence> implements ITrackSequenceService {

    private static final String MASC = "MASC";
    private static final String CAT = "CAT";

    @Value("${server.task_stop_url_cat}")
    private String task_stop_url;

    @Autowired
    private AlgorithmConfigTrackServiceImpl algorithmConfigTrackService;
    @Autowired
    private AlgorithmModelTrackServiceImpl algorithmModelTrackService;

    @Autowired
    private ISysOssService ossService;

    @Resource
    private TrackSequenceMapper trackSequenceMapper;

    @Override
    public QueryWrapper query() {
        return super.query().from(TRACK_SEQUENCE);
    }

    private QueryWrapper buildQueryWrapper(TrackSequenceBo trackSequenceBo) {
        QueryWrapper queryWrapper = super.buildBaseQueryWrapper();
        queryWrapper.and(TRACK_SEQUENCE.NAME.like(trackSequenceBo.getName()));
        queryWrapper.and(TRACK_SEQUENCE.STATUS.eq(trackSequenceBo.getStatus()));
        queryWrapper.and(TRACK_SEQUENCE.START_TIME.eq(trackSequenceBo.getStartTime()));
        queryWrapper.and(TRACK_SEQUENCE.END_TIME.eq(trackSequenceBo.getEndTime()));
        queryWrapper.and(TRACK_SEQUENCE.COST_SECOND.eq(trackSequenceBo.getCostSecond()));
        queryWrapper.and(TRACK_SEQUENCE.LOG.eq(trackSequenceBo.getLog()));
        queryWrapper.and(TRACK_SEQUENCE.REMARKS.eq(trackSequenceBo.getRemarks()));
        queryWrapper.and(TRACK_SEQUENCE.URL.eq(trackSequenceBo.getUrl()));
        queryWrapper.and(TRACK_SEQUENCE.INPUT_OSS_ID.eq(trackSequenceBo.getInputOssId()));
        queryWrapper.and(TRACK_SEQUENCE.INPUT_PATH.eq(trackSequenceBo.getInputPath()));
        queryWrapper.and(TRACK_SEQUENCE.OUTPUT_PATH.eq(trackSequenceBo.getOutputPath()));
        queryWrapper.and(TRACK_SEQUENCE.ZIP_FILE_PATH.eq(trackSequenceBo.getZipFilePath()));

        return queryWrapper;
    }

    /**
     * 查询注视轨迹序列
     *
     * @param id 注视轨迹序列主键
     * @return 注视轨迹序列
     */
    @Override
    public TrackSequenceVo selectById(Long id) {
        return this.getOneAs(query().where(TRACK_SEQUENCE.ID.eq(id)), TrackSequenceVo.class);

    }

    /**
     * 查询注视轨迹序列列表
     *
     * @param trackSequenceBo 注视轨迹序列Bo
     * @return 注视轨迹序列集合
     */
    @Override
    public List<TrackSequenceVo> selectList(TrackSequenceBo trackSequenceBo) {
        QueryWrapper queryWrapper = buildQueryWrapper(trackSequenceBo);
        return this.listAs(queryWrapper, TrackSequenceVo.class);
    }

    /**
     * 分页查询注视轨迹序列列表
     *
     * @param trackSequenceBo 注视轨迹序列Bo
     * @return 分页注视轨迹序列集合
     */
    @Override
    public PageResult<TrackSequenceVo> selectPage(TrackSequenceBo trackSequenceBo) {
        QueryWrapper queryWrapper = buildQueryWrapper(trackSequenceBo);
        Page<TrackSequenceVo> page = this.pageAs(PageQuery.build(), queryWrapper, TrackSequenceVo.class);
        page.getRecords().forEach(entity -> {
            Long modelId = entity.getAlgorithmModelId();
            Long algorithmId = entity.getAlgorithmId();
            if (modelId != null) {
                AlgorithmModelTrackVo model = algorithmModelTrackService.selectById(modelId);
                if (ObjectUtil.isNotNull(model)) {
                    entity.setModelName(model.getModelName());
                }
            }
            if (algorithmId != null) {
                AlgorithmConfigTrackVo config = algorithmConfigTrackService.selectById(algorithmId);
                if (ObjectUtil.isNotNull(config)) {
                    entity.setType(config.getType());
                    entity.setSubsystem(config.getSubsystem());
                    entity.setAlgorithmName(config.getAlgorithmName());
                }
            } else {
                AlgorithmModelTrackVo model = algorithmModelTrackService.selectById(modelId);
                if (ObjectUtil.isNotNull(model)) {
                    AlgorithmConfigTrackVo config = algorithmConfigTrackService.selectById(model.getAlgorithmId());
                    if (ObjectUtil.isNotNull(config)) {
                        entity.setType(config.getType());
                        entity.setSubsystem(config.getSubsystem());
                        entity.setAlgorithmName(config.getAlgorithmName());
                    }
                }
            }
        });
        return PageResult.build(page);
    }

    /**
     * 新增注视轨迹序列
     *
     * @param trackSequenceBo 注视轨迹序列Bo
     * @return 结果:true 操作成功，false 操作失败
     */
    @Override
    public CommonResult insert(TrackSequenceBo trackSequenceBo) {
        // 检查任务名称
        if (ObjectUtil.isEmpty(trackSequenceBo.getName()) || (!trackSequenceBo.getName().startsWith(MASC) && !trackSequenceBo.getName().startsWith(CAT))) {
            return CommonResult.fail("任务命名错误，需以MASC或CAT开头！");
        }

        // 检查input_oss_id是否存在
        if (ObjectUtil.isNull(trackSequenceBo.getInputOssId())) {
            return CommonResult.fail("请上传模型");
        }

        SysOssVo ossEntity = ossService.getById(trackSequenceBo.getInputOssId());
        if (ObjectUtil.isNull(ossEntity)) {
            return CommonResult.fail("找不到指定模型！");
        }

        if (trackSequenceBo.getName().startsWith(MASC)) {
            if (ObjectUtil.isEmpty(trackSequenceBo.getAlgorithmId())) {
                return CommonResult.fail("请指定算法！");
            }

            AlgorithmConfigTrackVo config = algorithmConfigTrackService.selectById(trackSequenceBo.getAlgorithmId());
            if (ObjectUtil.isNull(config)) {
                return CommonResult.fail("找不到指定的算法！");
            }
        }

        TrackSequence trackSequence = new TrackSequence();

        BeanUtils.copyProperties(trackSequenceBo, trackSequence);

        trackSequence.setUrl(ossEntity.getUrl());

        String filePath = ossEntity.getFileName();
        String localPath = TaaisConfig.getProfile();
        String resourcePath = localPath + StringUtils.substringAfter(filePath, Constants.RESOURCE_PREFIX);
        trackSequence.setInputPath(resourcePath);

        String fileName = StringUtils.substringAfterLast(filePath, "/");
        String fileName_without_suffix = removeFileExtension(fileName);

        Path path = Paths.get(resourcePath);
        Path outPath = path.resolveSibling(fileName_without_suffix + "_images" + System.currentTimeMillis());
        trackSequence.setOutputPath(outPath.toString());

        trackSequence.setZipFilePath(path.resolveSibling(fileName_without_suffix + ".zip").toString());
        trackSequence.setStatus(NOT_START);


        boolean __ = this.save(trackSequence);// 使用全局配置的雪花算法主键生成器生成ID值
        if (__) {
            return CommonResult.success();
        } else {
            return CommonResult.fail();
        }
    }

    /**
     * 修改注视轨迹序列
     *
     * @param trackSequenceBo 注视轨迹序列Bo
     * @return 结果:true 更新成功，false 更新失败
     */
    @Override
    public boolean update(TrackSequenceBo trackSequenceBo) {
        TrackSequence trackSequence = MapstructUtils.convert(trackSequenceBo, TrackSequence.class);
        if (ObjectUtil.isNotNull(trackSequence) && ObjectUtil.isNotNull(trackSequence.getId())) {
            boolean updated = this.updateById(trackSequence);
            return updated;
        }
        return false;
    }

    /**
     * 批量删除注视轨迹序列
     *
     * @param ids 需要删除的注视轨迹序列主键集合
     * @return 结果:true 删除成功，false 删除失败
     */
    @Transactional
    @Override
    public boolean deleteByIds(Long[] ids) {
        return this.removeByIds(Arrays.asList(ids));
    }

    @Override
    public CommonResult start(Long id) {
        /*
         * WANGKANG 望维护此代码的后来者安息。
         *
         * 不是我想写这么恶心，只是没办法，算法端的逻辑写的跟屎一样。。。。
         */
        TrackSequence entity = getById(id);
        AlgorithmModelTrack algorithmModelTrack = algorithmModelTrackService.getById(entity.getAlgorithmModelId());
        AlgorithmConfigTrack algorithmConfigTrack = null;
        try {
            algorithmConfigTrack = algorithmConfigTrackService.getById(entity.getAlgorithmId());
        } catch (Exception e) {
            algorithmConfigTrack = algorithmConfigTrackService.getById(algorithmModelTrack.getAlgorithmId());
        }

        StartTaskConfig startTaskConfig = new StartTaskConfig();

        if (algorithmConfigTrack.getType().equals(BizConstant.AlgorithmType.TEST) && (entity.getName().startsWith(MASC) || entity.getName().startsWith(CAT))) {
            startTaskConfig.setBizType(BizConstant.BizType.TRACK_SEQUENCE);
            startTaskConfig.setBizId(entity.getId());

            startTaskConfig.setOtherParams(algorithmConfigTrack.getParameterConfig());

            startTaskConfig.setSource_dir(entity.getInputPath());
            startTaskConfig.setResult_dir(entity.getOutputPath());
            startTaskConfig.setLog_path(entity.getOutputPath() + File.separator + getLogFileName(entity));
        } else {
            SysOssVo inputOssEntity = ossService.getById(entity.getInputOssId());

            String filePath = inputOssEntity.getFileName();
            String localPath = TaaisConfig.getProfile();
            String resourcePath = localPath + StringUtils.substringAfter(filePath, Constants.RESOURCE_PREFIX);

            String fileName = StringUtils.substringAfterLast(filePath, "/");
            String fileName_without_suffix = removeFileExtension(fileName);

            Path path = Paths.get(resourcePath);
            Path inputPath = path.resolveSibling(fileName_without_suffix + BizConstant.UNZIP_SUFFIX);
            Path outputPath = path.resolveSibling(entity.getId().toString() + BizConstant.TRACK_SEQUENCE_SUFFIX);

//        makeDir(inputPath.toString());
            makeDir(outputPath.toString());

            File file = new File(inputPath.toString());
            if (!file.exists()) {
                ZipUtils.unzip(resourcePath, inputPath.toString());
            }

            entity.setInputPath(inputPath.toString());
            entity.setOutputPath(outputPath.toString());

            entity.setStartTime(new Date());

            startTaskConfig.setBizType(BizConstant.BizType.TRACK_SEQUENCE);
            startTaskConfig.setBizId(entity.getId());

            startTaskConfig.setOtherParams(algorithmConfigTrack.getParameterConfig());

            startTaskConfig.setSource_dir(entity.getInputPath());
            startTaskConfig.setResult_dir(entity.getOutputPath());
            startTaskConfig.setLog_path(entity.getOutputPath() + File.separator + getLogFileName(entity));

            if (BizConstant.AlgorithmType.REASONING.equals(algorithmConfigTrack.getType())) {
                String modelPath = algorithmModelTrack.getModelAddress();
                startTaskConfig.setModel_path(modelPath);
                if (entity.getName().startsWith(CAT)) {
                    startTaskConfig.setSource_dir(startTaskConfig.getSource_dir());
//                    File file________ = new File(startTaskConfig.getSource_dir());
//                    if (!file________.exists()) {
//                        return CommonResult.fail("数据集为空！");
//                    }
//                    if (file________.listFiles() != null && file________.listFiles().length > 0) {
//                        for (File file___________________tmp : file________.listFiles()) {
//                            if (file___________________tmp.isDirectory()) {
//                                startTaskConfig.setSource_dir(file___________________tmp.getPath());
//                                break;
//                            }
//                        }
//                    }

                    File file___________________________ = new File(startTaskConfig.getModel_path());
                    if (!file___________________________.exists()) {
                        return CommonResult.fail("模型不存在！");
                    }
                    if (file___________________________.listFiles() != null && file___________________________.listFiles().length > 0) {
                        for (File file___________________tmp : file___________________________.listFiles()) {
                            if (file___________________tmp.isDirectory()) {
                                startTaskConfig.setModel_path(file___________________tmp.getPath());
                                break;
                            }
                        }
                    }
                }
//            if (algorithmModelTrack.getModelName().startsWith("masc") || algorithmModelTrack.getModelName().startsWith("MASC")) {
//                String modelPath = algorithmModelTrack.getModelAddress() + File.separator + algorithmModelTrack.getModelName().substring(5);
//                startTaskConfig.setModel_path(modelPath);
//            } else if (algorithmModelTrack.getModelName().startsWith("cat") || algorithmModelTrack.getModelName().startsWith("CAT")) {
//                String modelPath = algorithmModelTrack.getModelAddress();
//                startTaskConfig.setModel_path(modelPath);
//            } else {
//                return CommonResult.fail("模型命名失败，请以MASC或CAT开头命名模型");
//            }
            } else if (BizConstant.AlgorithmType.TRAIN.equals(algorithmConfigTrack.getType()) && entity.getName().startsWith(CAT)) {
                File file________ = new File(startTaskConfig.getSource_dir());
                if (!file________.exists()) {
                    return CommonResult.fail("数据集为空！");
                }
                boolean flag = false;
                if (file________.listFiles() != null && file________.listFiles().length > 0) {
                    for (File file___________________tmp : file________.listFiles()) {
                        if (file___________________tmp.isDirectory()) {
                            startTaskConfig.setSource_dir(file___________________tmp.getPath());
                            flag = true;
//                            if (file___________________tmp.listFiles() != null && file___________________tmp.listFiles().length > 0) {
//                                for (File file________________________________________________________________________________________ : file___________________tmp.listFiles()) {
//                                    if (file________________________________________________________________________________________.isDirectory() &&
//                                        file________________________________________________________________________________________.getName().equals("images")) {
//                                        startTaskConfig.setSource_dir(file________________________________________________________________________________________.getPath());
//                                        flag = true;
//                                        break;
//                                    }
//                                }
//                            }
//                            break;
                        }
                    }
                }
                if (!(flag && !false && (1!=2) && (1 == 1))) {
                    return CommonResult.fail("数据集错误！！！！！！");
                }
            }
        }
        HttpResponseEntity responseEntity = sendPostMsg(algorithmConfigTrack.getAlgorithmAddress(), startTaskConfig);
        if (ObjectUtil.isNotNull(responseEntity) && responseEntity.getStatus() == 200) {
            entity.setStatus(BizConstant.VideoStatus.RUNNING);
            updateById(entity);
            return CommonResult.success("任务开始成功，请等待完成");
        } else {
            entity.setStatus(BizConstant.VideoStatus.FAILED);
            updateById(entity);
            return CommonResult.fail("任务开始失败，请检查！");
        }
    }

    @Override
    public CommonResult stop(Long id) {
        TrackSequence entity = getById(id);

        StartTaskConfig startTaskConfig = new StartTaskConfig();
        startTaskConfig.setBizType(BizConstant.BizType.TRACK_SEQUENCE);
        startTaskConfig.setBizId(entity.getId());

        HttpResponseEntity responseEntity = sendPostMsg(task_stop_url, startTaskConfig);
        if (ObjectUtil.isNotNull(responseEntity) && responseEntity.getStatus() == 200) {
            entity.setStatus(BizConstant.VideoStatus.INTERRUPTED);
            updateById(entity);
            return CommonResult.success("终止任务成功");
        } else {
            return CommonResult.fail("终止任务失败");
        }
    }

    @Override
    public ResponseEntity<org.springframework.core.io.Resource> zipImages(Long id) {
        TrackSequence entity = this.getById(id);
        if (ObjectUtil.isNull(entity)) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
        }

        String outputPath = "";
        String zipFilePath = "";

        AlgorithmModelTrack algorithmModelTrack = algorithmModelTrackService.getById(entity.getAlgorithmModelId());
        AlgorithmConfigTrack algorithmConfigTrack = algorithmConfigTrackService.getById(algorithmModelTrack.getAlgorithmId());

        if (BizConstant.AlgorithmType.REASONING.equals(algorithmConfigTrack.getType())) {
            outputPath = entity.getOutputPath() + File.separator + "predict";
            File file__ = new File(outputPath);
            if (!file__.exists()) {
                outputPath = entity.getOutputPath();
            }
            zipFilePath = outputPath + ".zip";
        } else if (BizConstant.AlgorithmType.TEST.equals(algorithmConfigTrack.getType())) {
            outputPath = entity.getOutputPath() + File.separator + "evaluate";
            File file__ = new File(outputPath);
            if (!file__.exists()) {
                outputPath = entity.getOutputPath();
            }
            zipFilePath = outputPath + ".zip";
        } else if (BizConstant.AlgorithmType.TRAIN.equals(algorithmConfigTrack.getType())) {
            outputPath = entity.getOutputPath();
            zipFilePath = outputPath + ".zip";
        } else {
            System.out.println("未知算法类型！");
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
        }

        File file = new File(zipFilePath);
        if (!file.exists()) {
            try {
                ZipUtils.zipFolderFiles(outputPath, zipFilePath);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        if (!file.exists() || !file.isFile()) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
        }

        org.springframework.core.io.Resource resource = new FileSystemResource(file);
        return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getName() + "\"").header(HttpHeaders.CONTENT_TYPE, "application/octet-stream").body(resource);
    }

    @Override
    public CommonResult getResult(TaskTrackResultBo taskTrackResultBo) {
        Long id = taskTrackResultBo.getBizId();
        String status = taskTrackResultBo.getStatus();
        String msg = taskTrackResultBo.getMsg();
        TrackSequence entity = getById(id);
        entity.setLog(msg);
        entity.setStatus("200".equals(status) ? BizConstant.VideoStatus.END : BizConstant.VideoStatus.FAILED);
        entity.setEndTime(new Date());
        try {
            entity.setCostSecond((entity.getEndTime().getTime() - entity.getStartTime().getTime()) / 1000);
        } catch (Exception e) {
            entity.setCostSecond(null);
        }
        updateById(entity);

        AlgorithmModelTrack algorithmModelTrack = algorithmModelTrackService.getById(entity.getAlgorithmModelId());
        algorithmModelTrack.setModelStatus("200".equals(status) ? BizConstant.ModelStatus.END : BizConstant.ModelStatus.FAILED);

        AlgorithmConfigTrack algorithmConfigTrack = algorithmConfigTrackService.getById(algorithmModelTrack.getAlgorithmId());
        String params = algorithmConfigTrack.getParameterConfig();
        HashMap<String, Object> parse = (HashMap<String, Object>) JSON.parse((params));

        if ("200".equals(status) && ObjectUtil.isNull(algorithmModelTrack.getModelAddress())) {
            algorithmModelTrack.setModelAddress(entity.getOutputPath() + File.separator + ((HashMap<String, String>) parse.get("dataset")).get("classes"));

            System.out.println(parse.get("dataset"));
            algorithmModelTrackService.updateById(algorithmModelTrack);
        }
        return CommonResult.success();
    }

    private String getLogFileName(TrackSequence entity) {
        return entity.getId() + BizConstant.TRACK_SEQUENCE_SUFFIX + ".log";
    }

    @Override
    public CommonResult getLog(Long id) {
        TrackSequence entity = getById(id);
        String outPutPath = entity.getOutputPath();
        String logPath = outPutPath + File.separator + getLogFileName(entity);
        System.out.println(logPath);
        File file = new File(logPath);
        if (!file.exists()) {
            return CommonResult.fail("日志文件不存在！");
        }
        return CommonResult.success(readLogContent(logPath), "success");
    }

    @Override
    public CommonResult getDetail(Long id) {
        TrackSequenceVo entity = selectById(id);
        if (entity.getName().startsWith(MASC)) {
            AlgorithmModelTrack modelTrack = algorithmModelTrackService.getById(entity.getAlgorithmModelId());
            AlgorithmConfigTrack algorithmConfigTrack = algorithmConfigTrackService.getById(entity.getAlgorithmId());

            AlgorithmModelTrackVo res = new AlgorithmModelTrackVo();

            BeanUtils.copyProperties(modelTrack, res);
            BeanUtils.copyProperties(algorithmConfigTrack, res);

            res.setAlgorithmId(algorithmConfigTrack.getId());
            res.setId(modelTrack.getId());

            return CommonResult.success(res, "success");
        } else if (entity.getName().startsWith(CAT)) {
            AlgorithmModelTrack modelTrack = algorithmModelTrackService.getById(entity.getAlgorithmModelId());
            AlgorithmConfigTrack algorithmConfigTrack = algorithmConfigTrackService.getById(modelTrack.getAlgorithmId());

            AlgorithmModelTrackVo res = new AlgorithmModelTrackVo();

            BeanUtils.copyProperties(modelTrack, res);
            BeanUtils.copyProperties(algorithmConfigTrack, res);

            res.setAlgorithmId(algorithmConfigTrack.getId());
            res.setId(modelTrack.getId());

            return CommonResult.success(res, "success");
        } else {
            return CommonResult.fail("命名错误！");
        }
    }

    @Override
    public CommonResult addEvaluate(AddEvaluate addEvaluate) {
        // 检查任务名称
        if (ObjectUtil.isEmpty(addEvaluate.getName()) || (!addEvaluate.getName().startsWith(MASC) && !addEvaluate.getName().startsWith(CAT))) {
            return CommonResult.fail("任务命名错误，需以MASC或CAT开头！");
        }

        if (ObjectUtil.isEmpty(addEvaluate.getAlgorithmId())) {
            return CommonResult.fail("请指定算法！");
        }

        AlgorithmConfigTrackVo config = algorithmConfigTrackService.selectById(addEvaluate.getAlgorithmId());
        if (ObjectUtil.isNull(config)) {
            return CommonResult.fail("找不到指定的算法！");
        }

        TrackSequence entity = this.getById(addEvaluate.getId());
        TrackSequence evaluate_entity = new TrackSequence();
        evaluate_entity.setStatus(NOT_START);
        evaluate_entity.setUrl(entity.getUrl());
        if (addEvaluate.getName().startsWith(MASC)) {
            evaluate_entity.setInputPath(entity.getInputPath() + ";" + entity.getOutputPath() + File.separator + "gaze" + File.separator + "txt");
        } else if (addEvaluate.getName().startsWith(CAT)) {
            File file________ = new File(entity.getInputPath());
            if (!file________.exists()) {
                return CommonResult.fail("数据集为空！");
            }
            evaluate_entity.setInputPath(entity.getInputPath() + ";" + entity.getOutputPath() + File.separator + "txt");
//            if (file________.listFiles() != null && file________.listFiles().length > 0) {
//                for (File file___________________tmp : file________.listFiles()) {
//                    if (file___________________tmp.isDirectory()) {
//                        evaluate_entity.setInputPath(file___________________tmp.getPath() + ";" + entity.getOutputPath() + File.separator + "txt");
//                        break;
//                    }
//                }
//            }
        } else {
            return CommonResult.fail("命名错误！");
        }
        evaluate_entity.setZipFilePath(entity.getZipFilePath());
        evaluate_entity.setAlgorithmModelId(entity.getAlgorithmModelId());
        evaluate_entity.setInputOssId(entity.getInputOssId());

        evaluate_entity.setName(addEvaluate.getName());
        evaluate_entity.setAlgorithmId(addEvaluate.getAlgorithmId());
        evaluate_entity.setRemarks(addEvaluate.getRemarks());

        boolean flag__ = save(evaluate_entity);

        if (flag__) {
            Path path = Paths.get(entity.getOutputPath());
            evaluate_entity.setOutputPath(path.resolveSibling(evaluate_entity.getId().toString() + BizConstant.TRACK_SEQUENCE_SUFFIX).toString());
            boolean flag___ = updateById(evaluate_entity);
            if (flag___) {
                return CommonResult.success("新增评估任务成功！");
            } else {
                return CommonResult.success("新增评估任务成功！ 更新输出路径失败");
            }
        } else {
            return CommonResult.success("新增评估任务失败！");
        }
    }

    @Override
    public CommonResult getModelList(Long id) {
        TrackSequence entity = getById(id);
        String outPutPath = entity.getOutputPath();
        String modelPath = outPutPath;
        File modelDir = new File(modelPath);
        if (!modelDir.exists()) {
            return CommonResult.fail("模型输出目录不存在！");
        }
        File[] files = modelDir.listFiles();
        Integer idx = 0;
        ArrayList<Map<String, String>> res = new ArrayList<>();
        for (File file : files) {
            if (!file.isDirectory()) {
                continue;
            }
            idx += 1;
            Map<String, String> tmp = new HashMap<>();
            tmp.put("id", idx.toString());
            tmp.put("name", file.getName());
            String filePath = file.getPath();
            tmp.put("path", filePath);
            // todo 获取真正的url
            // http://localhost:9090/profile/upload/2024/10/27/1_1729404909511_20241027153840A001.zip
            String url = "http://localhost:" + port + Constants.RESOURCE_PREFIX + filePath.substring(TaaisConfig.getProfile().length());
            url = url.replaceAll("\\\\", "/"); // windows
            tmp.put("url", url);

            double fileSize = (getFileSize(file) / (1024.0 * 1024.0));
            DecimalFormat decimalFormat = new DecimalFormat("#.##");
            String formatFileSize = decimalFormat.format(fileSize);
            tmp.put("size", formatFileSize + "MB");
            res.add(tmp);
        }
        return CommonResult.success(res, "success");
    }

}
