package org.sxkj.odm.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.logging.log4j.util.Strings;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Point;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.oss.model.BladeFile;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import org.sxkj.common.constant.CacheConstant;
import org.sxkj.common.constant.CommonConstant;
import org.sxkj.common.enums.AttachResultTypeEnum;
import org.sxkj.common.enums.WaylineTypeEnum;
import org.sxkj.odm.enums.OdmTypeEnum;
import org.sxkj.odm.enums.WebOdmProjectIdEnum;
import org.sxkj.common.func.Streams;
import org.sxkj.common.model.ResponseResult;
import org.sxkj.common.model.TimeRange;
import org.sxkj.common.redis.RedisOpsUtils;
import org.sxkj.common.utils.*;
import org.sxkj.odm.build.DevicePermissionBuilder;
import org.sxkj.odm.config.MinioDataConstant;
import org.sxkj.odm.config.OdmProperties;
import org.sxkj.odm.config.PyToolsServiceProperties;
import org.sxkj.odm.constant.OdmConstant;
import org.sxkj.odm.constant.RedisKeyConstant;
import org.sxkj.odm.constant.TifConstant;
import org.sxkj.odm.entity.*;
import org.sxkj.odm.enums.WebOdmStatusEnum;
import org.sxkj.odm.mapper.OdmTaskInfoMapper;
import org.sxkj.odm.service.*;
import org.sxkj.odm.utils.GeoJsonToWktConverterUtils;
import org.sxkj.odm.utils.ParseTifUtils;
import org.sxkj.odm.utils.TreeUtils;
import org.sxkj.odm.utils.VideoConverterUtils;
import org.sxkj.odm.vo.*;
import org.sxkj.resource.vo.AttachTypeStatisticsVO;
import org.sxkj.tools.feign.IObjConvertClient;
import org.sxkj.tools.feign.ITifConvertClient;
import org.sxkj.resource.entity.Attach;
import org.sxkj.resource.feign.IAttachClient;
import org.sxkj.system.cache.SysCache;
import org.sxkj.system.feign.ISysClient;
import org.sxkj.system.vo.TreeVo;
import org.sxkj.tools.model.TifConvertResult;

import javax.net.ssl.HttpsURLConnection;
import java.io.*;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.MessageFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static org.sxkj.odm.utils.FileUtils.deletedFile;

/**
 * odm 任务信息服务实现层
 *
 * @author zhongrj
 * @date 2024-09-11
 */
@Slf4j
@Service
public class OdmTaskInfoServiceImpl extends ServiceImpl<OdmTaskInfoMapper, OdmTaskInfo> implements IOdmTaskInfoService {

	@Autowired
	private WebOdmSendRequest sendRequest;

	@Autowired
	private PyTifSendRequest pyTifSendRequest;

	@Autowired
	private OdmTaskThreadService odmTaskThreadService;

	@Autowired
	private MinioDataConstant minioDataConstant;

	@Autowired
	private IAttachClient attachClient;

	@Autowired
	private AsyncService asyncService;

	@Autowired
	private ISysClient sysClient;

	@Autowired
	private IObjConvertClient objConvertClient;

	@Autowired
	private ITifConvertClient tifConvertClient;

	@Value("${odm.down.temp.basePath}")
	private String odmDownTempBasePath;

	@Value("${odm.down.temp.preFix}")
	private String odmDownPreFixPath;

	@Value("${odm.down.temp.zipBasePath}")
	private String odmDownTempZipBasePath;

	@Autowired
	private BladeRedis bladeRedis;

	@Autowired
	private OdmProperties odmProperties;

	@Autowired
	private PyToolsServiceProperties pyToolsServiceProperties;

	@Autowired
	private DevicePermissionBuilder permissionBuilder;


	/**
	 * 自定义分页列表查询
	 *
	 * @param page
	 * @param odmTaskInfo
	 * @return
	 */
	@Override
	public IPage<OdmTaskInfoVO> selectOdmTaskInfoPage(IPage<OdmTaskInfoVO> page, OdmTaskInfoVO odmTaskInfo) {
		if (!AuthUtil.isAdministrator() && !Strings.isBlank(AuthUtil.getDeptId())) {
			// odmTaskInfo.setDeptId(Long.parseLong(AuthUtil.getDeptId()));
			List<Long> deptIdList = SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId()));
			odmTaskInfo.setDeptIdList(deptIdList);
			odmTaskInfo.setPermissionCondition(permissionBuilder.buildDataPermissionCondition(AuthUtil.getUserId(), "wj"));
		}
		// 查询并返回
		return page.setRecords(baseMapper.selectOdmTaskInfoPage(page, odmTaskInfo));
	}

	/**
	 * 创建 odm 任务--定时创建
	 *
	 * @return
	 */
	@Override
	public Boolean createWebOdmTask() {
		boolean flag = false;
		int num = 0;
		// 先查询在执行的任务数，超过1个就先不创建了
		Integer processTaskNum = baseMapper.getProcessTaskNum();
		if (processTaskNum >= OdmConstant.MAX_PROCESS_TASK_NUM) {
			log.info("在运行的任务超过{}个，延时创建任务",OdmConstant.MAX_PROCESS_TASK_NUM);
			return false;
		}
		// 查询所有未在 webodm 创建任务的任务信息
		List<OdmTaskInfoVO> list = baseMapper.getNotByWebOdmCreateTaskList();
		if (list.size() == 0) {
			return false;
		}
		// 遍历
		for (OdmTaskInfoVO odmTaskInfo : list) {
			flag = createWebOdmTask(odmTaskInfo.getWaylineJobId(), odmTaskInfo.getGsd());
			if (flag) {
				num++;
			}
		}
		if (num == list.size()) {
			return true;
		}
		return false;
	}

	/**
	 * odm 任务创建
	 *
	 * @param jobId  航线任务id
	 * @param ortRes 正射影像的分辨率，单位为 cm/pixel
	 * @return
	 */
	@Override
	public Boolean createWebOdmTask(String jobId, Double ortRes) {
		// 查询当前航线任务的类型（过滤掉不参与图片合并的类型），当前只要 2:航测  4：正射举证 5：倾斜摄影 6:视频切斜摄影
		Integer waylineType = baseMapper.getWaylineType(jobId, OdmConstant.ODM_TASK_OPTION_TYPE);
		// 如果不存在
		if (null == waylineType) {
			return false;
		}
		// 查询航线任务对应的图片url
		List<String> picList = baseMapper.getWaylinePicUrl(jobId, waylineType);
		Integer projectId = WebOdmProjectIdEnum.ORT.getProjectId();
		// 创建odm 任务,实景三维和白膜三维共用一个工程id:4
		List<Integer> tiltTaskTypes = OdmConstant.TILT_TASK_TYPES;
		List<Integer> altTaskTypes = OdmConstant.ALB_TASK_TYPES;
		if (tiltTaskTypes.contains(waylineType) || altTaskTypes.contains(waylineType)) {
			projectId = WebOdmProjectIdEnum.TD.getProjectId();
		}
		Boolean x = createOdmTask(jobId, ortRes, waylineType, picList, projectId);
		if (x != null) return x;
		// 完成任务创建
		return false;
	}

	/**
	 * 创建 odm 任务
	 *
	 * @param jobId       航线任务id
	 * @param ortRes      正射影像的分辨率，单位为 cm/pixel
	 * @param waylineType 航线任务类型
	 * @param picList     图片地址集合
	 * @return
	 */
	@Nullable
	private Boolean createOdmTask(String jobId, Double ortRes, Integer waylineType, List<String> picList, Integer projectId) {
		log.info("当前航线任务：{},对应的图片数量：{}", jobId, picList.size());
		if (picList.size() <= OdmConstant.MIN_PIC_NUM) {
			log.error("当前航线任务：{},对应的图片数量：{},少于{}张，无法创建任务", jobId, picList.size(),OdmConstant.MIN_PIC_NUM);
			throw new ServiceException("当前航线任务:" + jobId + ",对应的图片数量：" + picList.size() + ",少于" + OdmConstant.MIN_PIC_NUM + "张，无法创建任务");
		}
		// 设置 odm 任务创建参数
		Map<String, Object> map = setCreteOdmTaskParam(waylineType, ortRes);
		// url 格式化
		String createTaskUrl = MessageFormat.format(OdmConstant.CREATE_TASK_API, projectId);
		// 校验该次任务已经创建
		if (isCreateWebOdmTask(jobId, waylineType)) {
			log.error("webodm任务已经创建过了!jobId:{}", jobId);
			return false;
		}
		// 创建任务
		JSONObject jsonObject = sendRequest.sendPostJsonByMap(createTaskUrl, true, map);
		// 保存关联信息到表
		if (null == jsonObject) {
			log.error("创建任务失败!jobId:{}", jobId);
			return false;
		}
		// 上传对应的图片到 odm
		// 设置多线程进行图片上传,返回上传成功的文件数量
		int count = uploadWaylinePic(picList, jsonObject.getString("id"), projectId);
		log.info("当前航线任务：{},已成功上传odm图片数量：{}", jobId, count);
		if (count < OdmConstant.MIN_PIC_NUM) {
			log.error("已上传odm图片数量为:{},不符合要求，至少需要上传{}张图片！", count,OdmConstant.MIN_PIC_NUM);
			return false;
		}
		// 图片上传完成提交任务
		String taskId = jsonObject.getString("id");
		// url 格式化,odm 任务id 从创建任务返回的id 取
		String commitTaskUrl = MessageFormat.format(OdmConstant.COMMIT_TASK_API, projectId, taskId);
		jsonObject.put("images_count", count);
		jsonObject.put("partial", false);
		JSONObject commitTaskJson = sendRequest.sendPostJsonByJson(commitTaskUrl, true, jsonObject.toString());
		if (null != commitTaskJson) {
			// 获取odm 任务信息
			OdmTaskInfo odmTaskInfo = getOdmTaskInfo(jobId);
			// 更新 odm task 任务信息
			boolean update = updateOdmTaskInfo(count, commitTaskJson, odmTaskInfo);
			return update && true;
		}
		return null;
	}


	/**
	 * 定时补漏odm任务的的生成（由其他原因到时没有创建到任务的）
	 *
	 * @return
	 */
	@Override
	public Boolean leakRepairOdmTask() {
		int num = 0;
		// 先查询在执行的任务数，超过1个就先不创建了
		Integer processTaskNum = baseMapper.getProcessTaskNum();
		if (processTaskNum >= OdmConstant.MAX_PROCESS_TASK_NUM) {
			log.info("在运行的任务超过{}个，延时创建任务",OdmConstant.MAX_PROCESS_TASK_NUM);
			return false;
		}
		// 查询没有生成的odm任务航线任务，不包含已经删除的航线任务
		List<String> jobIds = baseMapper.getNoCreateTaskJob(OdmConstant.ODM_TASK_OPTION_TYPE);
		if (jobIds.size() == 0) {
			return false;
		}
		// 遍历生成任务
		for (String jobId : jobIds) {
			boolean flag = saveOdmTaskInfo(jobId);
			if (flag) {
				num++;
			}
		}
		return num == jobIds.size();
	}

	/**
	 * 保存 odm 任务信息
	 *
	 * @param jobId
	 * @return
	 */
	@Override
	public Boolean saveOdmTaskInfo(String jobId) {
		// 查询当前航线任务的类型（过滤掉不参与图片合并的类型），当前只要 2:航测（正射举证）  4：图斑正射举证  5:三维倾斜摄影 6:视频三维白膜
		Integer waylineType = baseMapper.getWaylineType(jobId, OdmConstant.ODM_TASK_OPTION_TYPE);
		// 如果不存在
		if (null == waylineType) {
			return false;
		}
		// 视频白膜
		if (waylineType == WaylineTypeEnum.ALB_COL.getType().intValue()) {
			// 判断是否有再处理视频的任务，如果有则不处理，没有才处理，防止cpu,内存使用过多
			String value = bladeRedis.get(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY);
			if (!Strings.isBlank(value)) {
				log.info("已存在处理的视频，待处理完成后执行，退出当前执行");
				return false;
			}
		}
		// 判断是否创建，没有则直接创建 odm 任务
		if (isCreateTask(jobId)) {
			return false;
		}
		// 查询航线任务对应的图片url
		List<String> picList = baseMapper.getWaylinePicUrl(jobId, waylineType);
		log.info("当前航线任务：{},对应的图片数量：{}", jobId, picList.size());
		if (waylineType != WaylineTypeEnum.ALB_COL.getType().intValue() && picList.size() <= OdmConstant.MIN_PIC_NUM) {
			log.error("当前航线任务：{},对应的图片数量：{},少于{}张，无法创建任务", jobId, picList.size(),OdmConstant.MIN_PIC_NUM);
			return false;
		}
		// 创建
		OdmTaskInfo odmTaskInfo = saveOdmTaskInfo(jobId, null, waylineType);
		if (null != odmTaskInfo) {
			return true;
		}
		return false;
	}

	/**
	 * 校验任务是否已经创建
	 *
	 * @param jobId
	 * @return
	 */
	private boolean isCreateTask(String jobId) {
		// 根据jobId 查询任务信息
		OdmTaskInfo odmTaskInfo = getOdmTaskInfo(jobId);
		if (null == odmTaskInfo) {
			return false;
		}
		return true;
	}

	/**
	 * 校验webodm任务是否已经创建
	 *
	 * @param jobId
	 * @return
	 */
	private boolean isCreateWebOdmTask(String jobId, Integer waylineType) {
		// 根据jobId 查询任务信息
		OdmTaskInfo odmTaskInfo = getOdmTaskInfo(jobId);
		if (null == odmTaskInfo) {
			// 没有就先创建
			saveOdmTaskInfo(jobId, null, waylineType);
			return false;
		}
		// 如果 taskId 已存在，则无需再创建webodm任务
		if (Strings.isBlank(odmTaskInfo.getTaskId())) {
			return false;
		}
		return true;
	}

	/**
	 * 获取odm 任务信息
	 *
	 * @param jobId
	 * @return
	 */
	private OdmTaskInfo getOdmTaskInfo(String jobId) {
		// 根据jobId 查询任务信息
		QueryWrapper<OdmTaskInfo> wrapper = new QueryWrapper<>();
		wrapper.eq("wayline_job_id", jobId);
		// 返回
		return baseMapper.selectOne(wrapper);
	}

	/**
	 * 保存odm 任务信息
	 *
	 * @param jobId
	 * @param taskId
	 * @param waylineType 航线类型
	 * @return
	 */
	public OdmTaskInfo saveOdmTaskInfo(String jobId, String taskId, Integer waylineType) {
		// 如果是视频的，需要单独处理
		if (waylineType == WaylineTypeEnum.ALB_COL.getType().intValue()) {
			videoToOdm(jobId);
		} else {
			OdmTaskInfo odmTaskInfo = new OdmTaskInfo();
			// 根据jobId 查询对应的设备编号
			String dockSn = baseMapper.getDeviceSnByJobId(jobId);
			odmTaskInfo.setDeviceSn(dockSn);
			OdmTaskInfo jobBaseInfo = baseMapper.selectJobBaseInfo(jobId);
			odmTaskInfo.setAreaCode(jobBaseInfo.getAreaCode());
			odmTaskInfo.setCreateUser(jobBaseInfo.getCreateUser());
			odmTaskInfo.setUpdateUser(jobBaseInfo.getUpdateUser());
			odmTaskInfo.setCreateDept(jobBaseInfo.getCreateDept());
			odmTaskInfo.setCreateTime(new Date());
			odmTaskInfo.setUpdateTime(new Date());
			odmTaskInfo.setProjectId(WebOdmProjectIdEnum.ORT.getProjectId());
			odmTaskInfo.setTaskId(taskId);
			odmTaskInfo.setWaylineJobId(jobId);
			if (null != waylineType && OdmConstant.TILT_TASK_TYPES.contains(waylineType)) {
				// 设置为倾斜摄影
				odmTaskInfo.setType(OdmTypeEnum.TILT.getType());
				odmTaskInfo.setProjectId(WebOdmProjectIdEnum.TD.getProjectId());
			}
			boolean save = this.save(odmTaskInfo);
			if (save) {
				return odmTaskInfo;
			}
		}
		return null;
	}

	/**
	 * 更新 odm 任务信息
	 *
	 * @param count
	 * @param jsonObject
	 * @return
	 */
	private boolean updateOdmTaskInfo(int count, JSONObject jsonObject, OdmTaskInfo odmTaskInfo) {
		odmTaskInfo.setTaskId(jsonObject.getString("id"));
		// 更新任务信息
		odmTaskInfo.setImageCount(count);
		odmTaskInfo.setUploadProgress(jsonObject.getDouble("upload_progress"));
		odmTaskInfo.setResizeProgress(jsonObject.getDouble("resize_progress"));
		odmTaskInfo.setRunningProgress(jsonObject.getDouble("running_progress"));
		odmTaskInfo.setProcessingTime(jsonObject.getLong("processing_time"));
		odmTaskInfo.setStatus(jsonObject.getInteger("status"));
		// 更新并返回
		return updateById(odmTaskInfo);
	}

	/**
	 * 设置多线程进行图片上传到 odm 对应的任务
	 *
	 * @param picList   图片url集合
	 * @param taskId    odm 任务id
	 * @param projectId odm 项目id
	 * @return
	 */
	private int uploadWaylinePic(List<String> picList, String taskId, Integer projectId) {
		int count = 0;
		// 创建Future列表来保存每个任务的结果
		List<Future<Boolean>> futures = new ArrayList<>();
		for (String url : picList) {
			// 提交任务
			futures.add(odmTaskThreadService.submit(() -> {
				// 这里执行你的异步任务
				return sendUploadWaylinePic(url, taskId, projectId);
			}));
		}
		// 收集并打印结果
		for (Future<Boolean> future : futures) {
			try {
				Boolean result = future.get();
				if (result) {
					count++;
				}
			} catch (Exception e) {
				log.error("异常信息-----》", e);
			}
		}
		return count;
	}

	/**
	 * 发送图片上传请求
	 *
	 * @param url
	 * @param taskId
	 * @return
	 */
	private Boolean sendUploadWaylinePic(String url, String taskId, Integer projectId) {
		// 获取图片进行上传到 odm,通过读取本地地址的方式获取图片流
		url = minioDataConstant.getServerBasePath() + minioDataConstant.getBucket() + url;
		File file = new File(url);
		// 检查文件是否存在
		if (!file.exists()) {
			log.error("文件 {} 不存在！", url);
			return false;
		}
		FileSystemResource fileResource = new FileSystemResource(file);
		// url 格式化,odm project_id 固定为3,odm 任务id 从创建任务返回的id 取
		String commitTaskUrl = MessageFormat.format(OdmConstant.UPLOAD_PIC_BY_TASK_API, projectId, taskId);
		MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
		multiValueMap.add("file", fileResource);
		// 发送上传请求
		JSONObject jsonObject = sendRequest.sendPostFormData(commitTaskUrl, true, multiValueMap);
		if (null == jsonObject) {
			return false;
		}
		Boolean success = jsonObject.getBoolean("success");
		if (success) {
			return true;
		}
		return false;
	}

	/**
	 * 设置拼图任务参数和选项数据
	 *
	 * @param waylineType 航线任务类型
	 * @param ortRes      正射影像的分辨率，单位为 cm/pixel(默认是5)
	 * @return
	 */
	@NotNull
	private Map<String, Object> setCreteOdmTaskParam(Integer waylineType, Double ortRes) {
		// 设置任务创建参数
		Map<String, Object> map = new HashMap<>(5);
		map.put("auto_processing_node", true);
		map.put("partial", true);
		map.put("processing_node", OdmConstant.PROCESS_NODE_NUM);
		// 图片压缩分辨率（-1 时代表不修改图片尺寸）
		if (waylineType == WaylineTypeEnum.TILT_WAY.getType().intValue() || waylineType == WaylineTypeEnum.GEO_WAY.getType().intValue()){
			// 斜面和几何做图片压缩调整，其他情况暂不做压缩
			map.put("resize_to", OdmConstant.RESIZE_VALUE);
		} else {
			map.put("resize_to", OdmConstant.NO_RESIZE_VALUE);
		}
		// 获取选项参数信息
		List<Map<String, Object>> options = OdmConstant.ODM_TASK_OPTION.get(waylineType);
		if (null != ortRes) {
			if (ortRes < 2) {
				ortRes = 2.0;
			}
			Double finalOrtRes = ortRes;
			Map<String, Object> ortResMap = new HashMap<>() {{
				put("name", "orthophoto-resolution");
				put("value", finalOrtRes);
			}};
			options.add(ortResMap);
		}
		map.put("options", options);
		// 返回
		return map;
	}

	/**
	 * 获取正射影像信息
	 *
	 * @param jobId 航线任务id
	 * @return
	 */
	@Override
	public String getOrthoimageUrl(String jobId) {
		// 根据jobId 查询导出对应的正射影像信息
		OdmTaskInfo odmTaskInfo = getOdmTaskInfo(jobId);
		if (null == odmTaskInfo) {
			return null;
		}
		// 格式化url
		String url = MessageFormat.format(OdmConstant.ORTHOPHOTO_EXPORT_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 配置请求参数
		MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
		multiValueMap.add("format", "gtiff");
		multiValueMap.add("epsg", "4326");
		//调用接口获取正射影像信息
		JSONObject jsonObject = sendRequest.sendPostFormData(url, true, multiValueMap);
		// 返回
		if (null == jsonObject) {
			return null;
		}
		// 拼接 url
		String tmpUrl = odmProperties.getHttpsPreFixUrl() + OdmConstant.GET_PHONE_URL;
		// 先适配 uuid
		String downloadUrl = MessageFormat.format(tmpUrl, jsonObject.getString("celery_task_id"));
		// 拼接
		downloadUrl = downloadUrl + "?filename=" + jsonObject.getString("filename");
		// 返回
		return downloadUrl;
	}

	/**
	 * 定时更新odm 任务状态
	 *
	 * @return
	 */
	@Override
	public Integer updateOdmTaskInfo() {
		int count = 0;
		// 查询 running_progress 小于 1 的任务,isUpdate 为 0 的
		List<OdmTaskInfoVO> odmTaskInfoList = baseMapper.selectOdmTaskListLess1();
		// 判断是否有
		if (odmTaskInfoList.size() == 0) {
			return count;
		}
		// 创建Future列表来保存每个任务的结果
		List<Future<Boolean>> futures = new ArrayList<>();
		for (OdmTaskInfoVO odmTaskInfo : odmTaskInfoList) {
			// 提交任务
			futures.add(odmTaskThreadService.submit(() -> {
				// 这里执行你的异步任务，更新任务状态
				return sendGetTaskInfoReqestAndUpdate(odmTaskInfo);
			}));
		}
		// 收集并打印结果
		for (Future<Boolean> future : futures) {
			try {
				Boolean result = future.get();
				if (result) {
					count++;
				}
			} catch (Exception e) {
				log.error("异常信息-----》", e);
			}
		}
		return count;
	}

	/**
	 * 更新任务状态
	 *
	 * @param odmTaskInfo
	 * @return
	 */
	private Boolean sendGetTaskInfoReqestAndUpdate(OdmTaskInfoVO odmTaskInfo) {
		log.info("开始更新任务状态,任务id:{}", odmTaskInfo.getTaskId());
		boolean flag = false;
		// 格式化url
		String url = MessageFormat.format(OdmConstant.GET_TASK_INFO_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		//调用接口从 webodm 获取任务信息
		JSONObject jsonObject = sendRequest.sendGetRequest(url, true);
		if (null == jsonObject) {
			return flag;
		}
		// 获取 状态值：running_progress等并更新
		odmTaskInfo.setUploadProgress(jsonObject.getDouble("upload_progress"));
		odmTaskInfo.setResizeProgress(jsonObject.getDouble("resize_progress"));
		odmTaskInfo.setRunningProgress(jsonObject.getDouble("running_progress"));
		odmTaskInfo.setProcessingTime(jsonObject.getLong("processing_time"));
		// 更新状态
		Integer status = jsonObject.getInteger("status");
		odmTaskInfo.setStatus(status);
		// 设置更新同步状态
		if (status == WebOdmStatusEnum.FAIL.getStatus().intValue() || status == WebOdmStatusEnum.COMPLETE.getStatus().intValue()) {
			// 设置为已更新完成
			odmTaskInfo.setIsUpdate(1);
		}
		if (status == WebOdmStatusEnum.FAIL.getStatus().intValue()) {
			// 设置错误消息
			odmTaskInfo.setLastError(jsonObject.getString("last_error"));
		}
		// 设置路径
		if (status == WebOdmStatusEnum.COMPLETE.getStatus().intValue()) {
			log.info("odm 拼图任务已完成,任务id:{},航线任务ID：{}", odmTaskInfo.getTaskId(), odmTaskInfo.getWaylineJobId());
			// 获取转换 api url
			// 设置地表模型tif 路径
			String demTifPath = MessageFormat.format(OdmConstant.DEM_TIF_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			// 获取运行环境信息
			String activeProfile = SpringContextUtil.getActiveProfile();
			// 设置地形文件（处理耗时较长）时配置 redis,防止重复调用
			String value = bladeRedis.get(RedisKeyConstant.ODM_DEM_KEY);
			if (!Strings.isBlank(value)) {
				return false;
			}
			// 设置缓存
			bladeRedis.setEx(RedisKeyConstant.ODM_DEM_KEY, "1", RedisKeyConstant.ODM_DEM_TIME);
			// 设置 dem 地表模型tif 路径
			odmTaskInfo.setDemTifPath(demTifPath);
			// 设置 正射范围4点空间面数据
			String geomStr = getGeom(odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId(), activeProfile);
			if (!Strings.isBlank(geomStr)) {
				odmTaskInfo.setGeom(geomStr);
			}
			// 格式化正射影像路径
			String orthoimagePath = MessageFormat.format(OdmConstant.ORTHO_IMAGE_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			// 格式化正射影像服务api
			String orthoimageApi = MessageFormat.format(OdmConstant.ORTHO_IMAGE_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId()) + OdmConstant.ORTHO_IMAGE_API_SUX;
			// 设置正射影像路径
			odmTaskInfo.setOrthoimagePath(orthoimagePath);
			// 设置正射影像图斑范围画面路径
			odmTaskInfo.setOrtTbPath(tifParse(odmTaskInfo.getDkbh(), true, orthoimagePath));
			// 设置正射影像api
			odmTaskInfo.setOrthoimageApi(orthoimageApi);
			// 航测文件倾斜摄影才有 3d-tiles 文件-修改为手动生成，自动生成的无法调参
//			if (odmTaskInfo.getType() == 1) {
//				String tiles3dPath = MessageFormat.format(OdmConstant.TILES_3D_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
//				odmTaskInfo.setTilesPath(tiles3dPath);
//			}
//			if (odmTaskInfo.getType() == 2) {
				// 调用 api 对 点云laz 生成 3d-tiles,设置对应的路径，这里去生成白膜-暂时关闭白膜处理，修改为单独处理，这里处理耗时过长会导致其他状态更新异常
//				setPointCloudTo3dTilesPath(odmTaskInfo, activeProfile);
//			}
		}
		if (Strings.isBlank(odmTaskInfo.getGeom())) {
			// 更新
			flag = updateById(odmTaskInfo);
		} else {
			// 手动更新
			int update = baseMapper.updateOdmTaskGeomInfoById(odmTaskInfo);
			flag = update > 0 ? true : false;
		}
		if (flag) {
			if (odmTaskInfo.getStatus()==WebOdmStatusEnum.COMPLETE.getStatus().intValue()
				&& odmTaskInfo.getType()==OdmTypeEnum.ORT.getType().intValue()) {
				// 更新正射影像tif 到 附件表
				updateOrthoimageAttach(odmTaskInfo);
			}
			// 更新三维白膜 到 附件表
			if (!Strings.isBlank(odmTaskInfo.getVoxGridTilesPath()) && odmTaskInfo.getType()==OdmTypeEnum.ALB.getType().intValue()) {
				update3dTilesAttach(odmTaskInfo, odmTaskInfo.getVoxGridTilesPath());
			}
			// 更新切斜摄影 到 附件表
			if (!Strings.isBlank(odmTaskInfo.getTilesPath()) && odmTaskInfo.getType()==OdmTypeEnum.TILT.getType().intValue()) {
				update3dTilesAttach(odmTaskInfo, odmTaskInfo.getTilesPath());
			}
		}
		// 删除缓存
		bladeRedis.del(RedisKeyConstant.ODM_DEM_KEY);
		// 返回
		return flag;
	}

	/**
	 * 更新白膜/倾斜摄影 到 附件表
	 *
	 * @param odmTaskInfo
	 */
	public boolean update3dTilesAttach(OdmTaskInfoVO odmTaskInfo, String filePath) {
		log.info("开始更新三维白膜/倾斜数据到附件表，odm任务id:{},航线任务id:{},文件路径:{}", odmTaskInfo.getTaskId(), odmTaskInfo.getWaylineJobId(), filePath);
		// 通过路径获取文件
		String path = odmTaskInfo.getBasePath() + filePath;
		File file = new File(path);
		// 检查文件是否存在
		if (!file.exists()) {
			log.error("三维白膜/倾斜数据文件 {} 不存在！", path);
			return false;
		}
		Attach attach = new Attach();
		// 计算设置文件大小
		attach.setAttachSize(file.length());
		// 设置文件路径，链接等
		attach.setDomainUrl(odmProperties.getDomainUrl());
		attach.setLink(odmProperties.getDomainUrl() + filePath);
		attach.setName(path);
		attach.setOriginalName(path);
		attach.setExtension(".json");
		// 设置航线对应的机构
		attach.setTenantId("000000");
		// 设置航线任务jobId
		if (!Strings.isBlank(odmTaskInfo.getWaylineJobId())) {
			attach.setPatrolTaskId(odmTaskInfo.getWaylineJobId());
		}
		// 设置类型-切斜摄影
		if (odmTaskInfo.getType() == OdmTypeEnum.TILT.getType().intValue()) {
			attach.setResultType(null);
		}
		// 设置类型-三维白膜
		if (odmTaskInfo.getType() == OdmTypeEnum.ALB.getType().intValue()) {
			attach.setResultType(null);
		}
		// 设置区域编号
		attach.setAreaCode(odmTaskInfo.getAreaCode());
		attach.setCreateUser(odmTaskInfo.getCreateUser());
		attach.setUpdateUser(odmTaskInfo.getUpdateUser());
		attach.setCreateDept(odmTaskInfo.getCreateDept());
		attach.setCreateTime(new Date());
		attach.setUpdateTime(new Date());
		if (!Strings.isBlank(odmTaskInfo.getCompletedTime())) {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		}
		// 设置设备编号
		if (!Strings.isBlank(odmTaskInfo.getDeviceSn())) {
			attach.setDeviceSn(odmTaskInfo.getDeviceSn());
		}
		if (!Strings.isBlank(odmTaskInfo.getWorkspaceId())) {
			attach.setWorkspaceId(odmTaskInfo.getWorkspaceId());
		}
		log.info("发起远程调用保存三维白膜/倾斜附件信息,tif 路径：{}", path);
		Boolean isSaveAttach = attachClient.saveAttachInfo(attach);

		// 返回
		return isSaveAttach;
	}

	/**
	 * 调用 api 对 obj 生成 3d-tiles,设置对应的路径
	 *
	 * @param odmTaskInfo
	 * @param activeProfile
	 */
	private void setVoxGridTilesPath(OdmTaskInfoVO odmTaskInfo, String activeProfile) {
		log.info("开始处理倾斜数据");
		String objPath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.OBJ_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 中心点文件路径
		String posFilePath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.CENTER_FILE_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// obj 转体素化网格 3d-tiles
		String objConvVoxGrid3dTilesUrl = pyToolsServiceProperties.getPyToolsService() + TifConstant.OBJ_VOX_GRID_3D_TILES_API;
		// 设置请求参数
		Map<String, Object> map = new HashMap<>(2);
		map.put("obj_path", objPath);
		map.put("pos_file_path", posFilePath);
		// 远程调用接口获取结果
		String result = pyTifSendRequest.sendPostJsonByMap(objConvVoxGrid3dTilesUrl, map);
		log.info("当前任务编号：{},处理obj后的 3d-tiles 路径是：{}", odmTaskInfo.getTaskId(), result);
		if (!Strings.isBlank(result)) {
			String replaceAll = result.replaceAll("^\"|\"$", "");
			String regex = odmProperties.getWebodmDataBasePath();
			String[] split = replaceAll.split(regex);
			// 设置体素网格 3d-tiles 文件路径
			odmTaskInfo.setVoxGridTilesPath(split[1] + "/tileset.json");
		}
	}

	/**
	 * 调用 api 对 点云生成 3d-tiles,设置对应的路径
	 *
	 * @param odmTaskInfo
	 * @param activeProfile
	 */
	private void setPointCloudTo3dTilesPath(OdmTaskInfoVO odmTaskInfo, String activeProfile) {
		log.info("开始处理点云数据，通过点云提取建筑然后生成白膜数据...");
		// obj 转体素化网格 3d-tiles
		String pointCloudPath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.POINT_CLOUD_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 拼接 url
		String pointCloudTo3dTilesUrl = pyToolsServiceProperties.getPyToolsService() + TifConstant.POINT_CLOUD_TO_3D_TILES_API;
		Map<String, Object> map = new HashMap<>(2);
		map.put("piontcloud_path", pointCloudPath);
		map.put("wayline_job_id", odmTaskInfo.getWaylineJobId());
		// 远程调用接口获取结果
		String result = pyTifSendRequest.sendPostJsonByMap(pointCloudTo3dTilesUrl, map);
		log.info("当前任务编号：{},处理点云后的 3d-tiles 路径是：{}", odmTaskInfo.getTaskId(), result);
		if (!Strings.isBlank(result)) {
			String replaceAll = result.replaceAll("^\"|\"$", "");
			String regex = odmProperties.getWebodmDataBasePath();
			String[] split = replaceAll.split(regex);
			// 设置体素网格 3d-tiles 文件路径
			odmTaskInfo.setVoxGridTilesPath(split[1] + "/tileset.json");
		}
	}

	/**
	 * 调用 api 对 obj 生成 3d-tiles,设置对应的路径
	 *
	 * @param odmTaskInfo
	 * @param activeProfile
	 */
	private void setObjTo3dTilesPath(OdmTaskInfoVO odmTaskInfo, String activeProfile) {
		log.info("开始处理obj数据，通过obj生成实景三维倾斜数据...");
		// 设置 obj 路径、中心点文件路径
		String objPath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.OBJ_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 中心点文件路径
		String posFilePath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.CENTER_FILE_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 设置请求参数
		Map<String, Object> map = new HashMap<>(2);
		map.put("obj_path", objPath);
		map.put("pos_file_path", posFilePath);
		// 远程调用接口获取结果
		String result = objConvertClient.obj2TilesModel(map);
		log.info("当前任务编号：{},处理obj后的 3d-tiles 路径是：{}", odmTaskInfo.getTaskId(), result);
		if (!Strings.isBlank(result)) {
			String replaceAll = result.replaceAll("^\"|\"$", "");
			String regex = odmProperties.getWebodmDataBasePath();
			String[] split = replaceAll.split(regex);
			// 设置体素网格 3d-tiles 文件路径
			odmTaskInfo.setTilesPath(split[1] + "/tileset.json");
		}
	}

	/**
	 * 设置 正射范围4点空间面数据
	 *
	 * @param projectId     工程id
	 * @param taskId        任务id
	 * @param activeProfile
	 * @return
	 */
	private String getGeom(Integer projectId, String taskId, String activeProfile) {
		// 读取文件获取EPSG:4326的面数据
		try {
			String modelInfoFilePath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.MODEL_INFO_FILE_PATH, projectId, taskId);
			String wktData = GeoJsonToWktConverterUtils.jsonFileToWktData(modelInfoFilePath);
			log.debug("得到的 wkt 面数据为：{}", wktData);
			if (Strings.isBlank(wktData)){
				return null;
			}
			return "'" + wktData + "'";
		} catch (Exception e) {
			e.printStackTrace();
			log.error("地表模型和面数据解析异常");
			throw new ServiceException("地表模型和面数据解析异常");
		}
	}

	/**
	 * 设置 dem 地表模型tif 路径
	 *
	 * @param odmTaskInfo
	 * @param demTifPath
	 * @param activeProfile
	 */
	private void setDemTifPath(OdmTaskInfoVO odmTaskInfo, String demTifPath, String activeProfile) {
		// 设置 tif 路径
		demTifPath = odmProperties.getWebodmDataBasePath() + demTifPath;
		// tif 转换 geotiff 4326
		String parseTifUrl = pyToolsServiceProperties.getPyToolsService() + TifConstant.PARSE_TIF_CONV_API;
		Map<String, Object> map = new HashMap<>(1);
		map.put("dsm_path", demTifPath);
		// 远程调用接口获取结果
		String result = pyTifSendRequest.sendPostJsonByMap(parseTifUrl, map);
		if (!Strings.isBlank(result)) {
			String replaceAll = result.replaceAll("^\"|\"$", "");
			String regex = odmProperties.getWebodmDataBasePath();
			String[] split = replaceAll.split(regex);
			// 设置 dem 数字地表模型tif 路径
			odmTaskInfo.setDemTifPath(split[1]);
		}
	}

	/**
	 * 更新正射影像tif 到 附件表
	 *
	 * @param odmTaskInfo
	 */
	private Boolean updateOrthoimageAttach(OdmTaskInfoVO odmTaskInfo) {
		if (odmTaskInfo.getType() == 0) {
			log.info("开始更新正射影像tif 到 附件表,航线任务id:{}...", odmTaskInfo.getWaylineJobId());
			// 保存tif 数据到 附件表
			// 通过路径获取文件
			String path = odmTaskInfo.getBasePath() + odmTaskInfo.getOrthoimagePath();
			File file = new File(path);
			// 检查文件是否存在
			if (!file.exists()) {
				log.error("文件 {} 不存在！", path);
				return false;
			}
			// 同时压缩图片
			Attach attach = new Attach();
			// 计算设置文件大小
			attach.setAttachSize(file.length());
			// 设置文件路径，链接等
			attach.setDomainUrl(odmProperties.getDomainUrl());
			attach.setLink(odmProperties.getDomainUrl() + odmTaskInfo.getOrthoimagePath());
			attach.setName(path);
			attach.setNickName(odmTaskInfo.getWaylineJobName());
			attach.setOriginalName(path);
			attach.setExtension(".tif");
			// 设置航线对应的机构
			attach.setAreaCode(odmTaskInfo.getAreaCode());
			attach.setCreateUser(odmTaskInfo.getCreateUser());
			attach.setUpdateUser(odmTaskInfo.getUpdateUser());
			attach.setCreateDept(odmTaskInfo.getCreateDept());
			attach.setCreateTime(new Date());
			attach.setUpdateTime(new Date());
			attach.setTenantId("000000");
			// 设置航线任务jobId
			if (!Strings.isBlank(odmTaskInfo.getWaylineJobId())) {
				attach.setPatrolTaskId(odmTaskInfo.getWaylineJobId());
			}
			// 设置类型
			attach.setResultType(null);
			// 设置设备编号
			if (!Strings.isBlank(odmTaskInfo.getDeviceSn())) {
				attach.setDeviceSn(odmTaskInfo.getDeviceSn());
			}
			if (!Strings.isBlank(odmTaskInfo.getWorkspaceId())) {
				attach.setWorkspaceId(odmTaskInfo.getWorkspaceId());
			}
			if (!Strings.isBlank(odmTaskInfo.getCompletedTime())) {
				DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
			}
			// 图片压缩
			log.info("开始压缩tif图片,路径：{}", path);
			Map<String, Object> map = new HashMap<>(1);
			map.put("ort_path", path);
			TifConvertResult tifConvertResult = tifConvertClient.tifConvJpeg(map);
			log.info("tif 图片压缩结果：{}", tifConvertResult);
			// 无需再上传
			if (null != tifConvertResult && !Strings.isBlank(tifConvertResult.getBasePath())) {
				log.info("tif 图片压缩成功,路径：{}", tifConvertResult.getBasePath());
				Boolean isSaveAttach = attachClient.saveAttachInfo(attach);
				if (isSaveAttach) {
					log.info("tif 图片保存成功,发起远程调用保存tif附件信息");
					return true;
				}
			}
		}
		return false;
	}


	public MultipartFile convertFileToMultipartFile(File file) {
		try {
			String fileName = file.getName();
			String contentType = Files.probeContentType(file.toPath());
			byte[] content = Files.readAllBytes(file.toPath());
			return new MockMultipartFile("file", fileName, contentType, content);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取正射影像服务信息
	 *
	 * @param dkbh        图斑编号
	 * @param workspaceId 项目id
	 * @return
	 */
	@Override
	public R getOrthoimageInfo(String dkbh, String workspaceId, String jobId) {
		Double runningProgress = 1.0;
		// 根据图斑编号 查询导出对应的正射影像信息
		OdmTaskInfoVO odmTaskInfo = baseMapper.getTbOrthoimageInfo(dkbh, runningProgress, jobId,OdmConstant.OTR_TASK_TYPES);
		if (null == odmTaskInfo) {
			return R.data(null);
		}
		// 设置 webODM访问token
		odmTaskInfo.setOdmToken("JWT " + sendRequest.getOdmToken());
		// 设置图斑中心点坐标，需要访问webodm接口获取，格式化url
		String url = MessageFormat.format(OdmConstant.GET_RTHOPHOTO_METADATA_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		//调用接口获取正射影像数据信息
		JSONObject jsonObject = sendRequest.sendGetRequest(url, true);
		// 返回
		if (null == jsonObject) {
			return R.data(odmTaskInfo);
		}
		// 设置中心点
		JSONArray center = jsonObject.getJSONArray("center");
		odmTaskInfo.setOrthoimageLng(center.get(0).toString());
		odmTaskInfo.setOrthoimageLng(center.get(1).toString());
		// 返回
		return R.data(odmTaskInfo);
	}

	/**
	 * 获取正射影像服务信息
	 *
	 * @param lotInfoId   图斑id
	 * @param workspaceId 项目id
	 * @return
	 */
	@Override
	public R getOrthoimageInfos(String lotInfoId, String workspaceId, String jobId) {
		Double runningProgress = 1.0;
		List<OdmTaskInfoVO> odmTaskInfoList = baseMapper.listTbOrthoimageInfoAsc(lotInfoId, runningProgress, jobId,OdmConstant.OTR_TASK_TYPES);

		if (CollectionUtils.isEmpty(odmTaskInfoList)) {
			return R.data(Collections.emptyList());
		}

		// --- 优化：将循环外不变的变量提前获取 ---
		String odmToken = "JWT " + sendRequest.getOdmToken();
		String activeProfile = SpringContextUtil.getActiveProfile(); // 获取一次环境配置
		String nowDateStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")); // 获取一次当前日期字符串

		// 遍历列表，为每个对象填充额外信息
		for (OdmTaskInfoVO taskInfo : odmTaskInfoList) {
			// 1. 设置 Token
			taskInfo.setOdmToken(odmToken);

			// 2. 设置中心点坐标
			String metaUrl = MessageFormat.format(OdmConstant.GET_RTHOPHOTO_METADATA_API, taskInfo.getProjectId(), taskInfo.getTaskId());
			JSONObject jsonObject = sendRequest.sendGetRequest(metaUrl, true);
			if (jsonObject != null) {
				JSONArray center = jsonObject.getJSONArray("center");
				if (center != null && center.size() >= 2) {
					taskInfo.setOrthoimageLng(center.get(0).toString());
					taskInfo.setOrthoimageLat(center.get(1).toString());
				}
				// 获取边界点
				String bounds = jsonObject.getJSONObject("bounds").getJSONArray("value").toJSONString();
				log.info("边界点：{}", bounds);
				taskInfo.setBounds(bounds);
			}

			// 3. 为当前 taskInfo 生成并设置下载 URL
			String downloadUrl = generateDownloadUrlForTask(taskInfo, activeProfile, nowDateStr);
			taskInfo.setDownloadUrl(downloadUrl);
		}

		return R.data(odmTaskInfoList);
	}

	/**
	 * 为单个任务信息对象生成下载链接。
	 * 该方法整合了原有的 getOdmTaskDownUrl 和 getMasTifUrl 的逻辑。
	 *
	 * @param taskInfo      任务信息对象
	 * @param activeProfile 当前运行环境
	 * @param nowDateStr    当前日期字符串 (yyyyMMdd)
	 * @return 生成的下载链接，如果失败则返回 null
	 */
	private String generateDownloadUrlForTask(OdmTaskInfoVO taskInfo, String activeProfile, String nowDateStr) {
		// 优先判断是否有裁剪好的图斑面（ortTbPath）
		if (!Strings.isBlank(taskInfo.getOrtTbPath())) {
			return odmProperties.getDomainUrl() + taskInfo.getOrtTbPath();
		}

		// 如果没有 ortTbPath，则执行文件复制并生成新的 URL
		try {
			// 确定输出目录
			String outDir = odmDownTempBasePath + "/" + nowDateStr;
			File dir = new File(outDir);
			if (!dir.exists()) {
				dir.mkdirs();
			}

			// 定义源文件和目标文件路径
			String inputPath = taskInfo.getBasePath() + taskInfo.getOrthoimagePath();
			String outPath = outDir + "/" + taskInfo.getDkbh() + ".tif";

			File newFile = new File(outPath);

			// --- 文件复制逻辑 ---
			// 使用 try-with-resources 语句，可以自动关闭流，更安全
			try (FileInputStream fileInputStream = new FileInputStream(inputPath);
				 FileOutputStream os = new FileOutputStream(newFile)) {
				IOUtils.copy(fileInputStream, os);
			}

			// 成功复制后，返回可访问的下载地址
			return odmDownPreFixPath + "/" + nowDateStr + "/" + taskInfo.getDkbh() + ".tif";

		} catch (IOException e) {
			// 使用日志记录错误，而不是打印到控制台
			log.error("为地块 {} 生成下载TIF文件失败: {}", taskInfo.getDkbh(), e.getMessage());
			return null; // 发生异常时返回 null
		}
	}


	/**
	 * 自定义删除
	 *
	 * @param idList
	 * @return
	 */
	@Override
	public Boolean removeOdmTaskByIds(List<Long> idList) {
		List<OdmTaskInfo> list = new ArrayList<>();
		int num1 = 0;
		int num2 = 0;
		// 遍历删除
		for (Long id : idList) {
			// 查询对应的任务信息
			OdmTaskInfo taskInfo = getById(id);
			list.add(taskInfo);
			// 删除
			boolean b = removeById(id);
			if (b) {
				num1++;
			}
		}
		// 删除webodm任务
		num2 = removeWebodmTask(list, num2);
		return num1 == num2;
	}

	/**
	 * 删除webodm任务
	 *
	 * @param list
	 * @param num2
	 * @return
	 */
	private int removeWebodmTask(List<OdmTaskInfo> list, int num2) {
		// 删除webodm上对应的任务
		for (OdmTaskInfo odmTaskInfo : list) {
			// 格式化url
			String url = MessageFormat.format(OdmConstant.REMOVE_TASK_INFO_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			//调用接口删除信息
			JSONObject jsonObject = sendRequest.sendPostFormData(url, true, null);
			// 返回
			if (null != jsonObject) {
				Boolean success = jsonObject.getBoolean("success");
				if (success) {
					num2++;
					// 异步删除对应的文件
					asyncService.deleteFileByTaskId(odmTaskInfo.getTaskId());
				}
			}
		}
		return num2;
	}

	/**
	 * 删除webodm任务
	 *
	 * @param list
	 * @return
	 */
	private boolean updateAndRemoveWebodmTask(List<OdmTaskInfo> list) {
		int num = 0;
		// 删除webodm上对应的任务
		for (OdmTaskInfo odmTaskInfo : list) {
			// 格式化url
			String url = MessageFormat.format(OdmConstant.REMOVE_TASK_INFO_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			//调用接口删除信息
			JSONObject jsonObject = sendRequest.sendPostFormData(url, true, null);
			// 返回
			if (null != jsonObject) {
				Boolean success = jsonObject.getBoolean("success");
				if (success) {
					// 异步删除对应的文件
					boolean result = asyncService.deleteFileByTaskId(odmTaskInfo.getTaskId());
					if (result) {
						odmTaskInfo.setFileDelFlag(1);
						// 更新删除状态
						updateById(odmTaskInfo);
						num++;
					}
				}
			}
		}
		// 返回结果
		return list.size() == num;
	}

	/**
	 * 定时任务----异常 odm 任务重试
	 *
	 * @return
	 */
	@Override
	public Boolean runErrorWebOdmTask() {
		int flag = 0;
		// 查询异常任务，异常次数3以下的，超过3次可以手动触发，不会自动进行重试 ，外加已取消的任务进行重启，暂定每次只处理一个，每次只查询一个
		List<OdmTaskInfo> list = baseMapper.getErrorWebOdmTaskList();
		if (list.size() == 0) {
			return true;
		}
		// 开始处理
		// 格式化重启任务url
		for (OdmTaskInfo odmTaskInfo : list) {
			String url = MessageFormat.format(OdmConstant.RESTART_TASK_API, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			//调用接口重启任务
			JSONObject jsonObject = sendRequest.sendPostFormData(url, true, null);
			// 返回
			if (null != jsonObject) {
				Boolean success = jsonObject.getBoolean("success");
				if (success) {
					flag++;
					int num = odmTaskInfo.getErrorNum();
					num++;
					// 更新odmTaskInfo 信息
					if (odmTaskInfo.getStatus() == WebOdmStatusEnum.FAIL.getStatus().intValue()) {
						odmTaskInfo.setErrorNum(num);
						odmTaskInfo.setLastError("");
					}
					odmTaskInfo.setRunningProgress(0.00);
					odmTaskInfo.setProcessingTime(0L);
					// 重置更新状态
					odmTaskInfo.setIsUpdate(0);
					// 更新
					baseMapper.updateById(odmTaskInfo);
				}
			}
		}
		// 返回
		return flag == list.size();
	}

	/**
	 * 更新正射影像tif 信息到  附件表
	 *
	 * @return
	 */
	@Override
	public R updateOrthoimageToAttach() {
		int count = 0;
		// 查询已完成的任务中没有将tif 信息同步到 附件表的信息
		List<OdmTaskInfoVO> list = baseMapper.getNoSaveAttachOdmTaskInfoList();
		// 遍历将tif 信息同步到附件表
		for (OdmTaskInfoVO odmTaskInfo : list) {
			Boolean flag = updateOrthoimageAttach(odmTaskInfo);
			if (flag) {
				count++;
			}
		}
		return R.status(count == list.size());
	}

	/**
	 * odm 任务重启
	 *
	 * @param taskId 航线任务id
	 * @return
	 */
	@Override
	public Boolean restartOdmTask(String taskId) {
		boolean flag = false;
		// 查询对应odm 信息
		QueryWrapper<OdmTaskInfo> wrapper = new QueryWrapper<>();
		wrapper.eq("task_id", taskId);
		OdmTaskInfo odmTaskInfo = getOne(wrapper);
		// 先重置
		resetOdmTask(taskId, odmTaskInfo.getProjectId());
		// 获取重启任务url
		String url = MessageFormat.format(OdmConstant.RESTART_TASK_API, odmTaskInfo.getProjectId(), taskId);
		//调用接口重启任务
		JSONObject jsonObject = sendRequest.sendPostFormData(url, true, null);
		// 返回
		if (null != jsonObject) {
			Boolean success = jsonObject.getBoolean("success");
			if (success) {
				// 更新odmTaskInfo 信息
				if (odmTaskInfo.getStatus() == WebOdmStatusEnum.FAIL.getStatus().intValue()) {
					odmTaskInfo.setLastError("");
				}
				odmTaskInfo.setRunningProgress(0.00);
				odmTaskInfo.setProcessingTime(0L);
				odmTaskInfo.setStatus(0);
				// 重置更新状态
				odmTaskInfo.setIsUpdate(0);
				// 更新
				int update = baseMapper.updateById(odmTaskInfo);
				if (update > 0) {
					flag = true;
				}
			}
		}
		return flag;
	}

	/**
	 * 重置信息
	 *
	 * @param taskId
	 * @param projectId
	 */
	private boolean resetOdmTask(String taskId, Integer projectId) {
		// 查询任务信息
		QueryWrapper<OdmTaskInfo> wrapper = new QueryWrapper<>();
		wrapper.eq("task_id", taskId);
		OdmTaskInfo odmTaskInfo = getOne(wrapper);
		// 查询当前航线任务的类型（过滤掉不参与图片合并的类型），当前只要 2:航测  4：正射举证 5：倾斜摄影 6:视频切斜摄影
		Integer waylineType = baseMapper.getWaylineType(odmTaskInfo.getWaylineJobId(), OdmConstant.ODM_TASK_OPTION_TYPE);
		// 如果不存在
		if (null == waylineType) {
			return false;
		}
		String url = MessageFormat.format(OdmConstant.PATCH_TASK_INFO_API, projectId, taskId);
		Map<String, Object> map = new HashMap<>(2);
		// 获取选项参数信息
		List<Map<String, Object>> options = OdmConstant.ODM_TASK_RESET_OPTIONS.get(waylineType);
		map.put("options", options);
		JSONObject jsonObject = sendRequest.sendPatchJsonByMap(url, true, map);
		if (null != jsonObject) {
			return true;
		}
		return false;
	}

	/**
	 * 获取odm 任务下载url
	 *
	 * @param dkbh
	 * @param workspaceId
	 * @return
	 */
	@Override
	public String getOdmTaskDownUrl(String dkbh, String workspaceId, String jobId) {
		Double runningProgress = 1.0;
		// 根据图斑编号 查询导出对应的正射影像信息
		OdmTaskInfoVO odmTaskInfo = baseMapper.getTbOrthoimageInfo(dkbh, runningProgress, jobId,OdmConstant.OTR_TASK_TYPES);
		if (null == odmTaskInfo) {
			return null;
		}
		// 判断是否有画好的图斑面，如果没有则正常取原tif图
		if (!Strings.isBlank(odmTaskInfo.getOrtTbPath())) {
			// 拼接 url
			return odmProperties.getDomainUrl() + odmTaskInfo.getOrtTbPath();
		}
		// 获取原tif重命名图
		return getMasTifUrl(dkbh, odmTaskInfo);
	}

	/**
	 * 获取原tif重命名图
	 *
	 * @param dkbh
	 * @param odmTaskInfo
	 * @return
	 */
	@NotNull
	private String getMasTifUrl(String dkbh, OdmTaskInfoVO odmTaskInfo) {
		// 下载tif 图片，重新赋名
		LocalDateTime currentTime = LocalDateTime.now();
		// 格式化时间，生成当前时间
		String nowDateStr = currentTime.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
		String outPath = odmDownTempBasePath + "/" + nowDateStr;
		// 获取路径
		String inputPath = odmTaskInfo.getBasePath() + odmTaskInfo.getOrthoimagePath();
//		String inputPath = "E:\\work\\temp\\odm\\odm_orthophoto.tif";
		//通过上传路径得到上传的文件夹
		File file = new File(outPath);
		//若目标文件夹不存在，则创建
		if (!file.exists()) {
			file.mkdirs();
		}
		//定义重新生成后的目标文件名
		outPath = outPath + "/" + dkbh + ".tif";
		File newFile = new File(outPath);
		// 根据目标文件的新建其输出流对象
		FileOutputStream os = null;
		try {
			FileInputStream fileInputStream = new FileInputStream(inputPath);
			os = new FileOutputStream(newFile);
			//完成输入流到输出流的复制
			IOUtils.copy(fileInputStream, os);
			//关闭流(先开后关)
			os.close();
			fileInputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		// 返回下载地址
		return odmDownPreFixPath + "/" + nowDateStr + "/" + dkbh + ".tif";
	}

	/**
	 * 定时删除odm临时文件任务
	 *
	 * @return
	 */
	@Override
	public boolean deletedOdmTempFile() {
		// 删除下载临时目录
		String path = odmDownTempBasePath;
		deletedFile(new File(path));
		// 删除下载临时zip目录
		// String zipPath = odmDownTempZipBasePath;
		// deletedFile(new File(zipPath));
		return true;
	}


	/**
	 * 定时删除odm拼图任务中失效的文件
	 *
	 * @return
	 */
	@Override
	public boolean deletedOdmTaskInVFile() {
		// 清理已删除的 odm 任务产生的文件（任务删除后没有删除掉对于的文件）
		List<Integer> typeList = new ArrayList<>();
		typeList.add(WebOdmProjectIdEnum.ORT.getProjectId());
		typeList.add(WebOdmProjectIdEnum.TD.getProjectId());
		for (Integer type : typeList) {
			// odm 任务查询 url
			String url = MessageFormat.format(OdmConstant.QUERY_TASK_API, type);
			//调用接口重启任务
			JSONArray jsonArray = sendRequest.sendGetRequestResArr(url, true);
			if (jsonArray.size() == 0) {
				log.error("没有查询到任务信息");
				return false;
			}
			List<String> nowList = new ArrayList<>();
			// 转换成taskId集合
			for (int i = 0; i < jsonArray.size(); i++) {
				nowList.add(jsonArray.getJSONObject(i).getString("id"));
			}
			// 读取对应文件目录列表
			String filePath = MessageFormat.format(odmProperties.getWebodmDataBasePath() + OdmConstant.TASK_FILE_PATH, type);
			File file = new File(filePath);
			File[] files = file.listFiles();
			if (null != files) {
				for (File f : files) {
					// 如果当前文件名（任务id）不存在已有的任务则删除
					if (!nowList.contains(f.getName())) {
						deletedFile(f);
					}
				}
			}
		}
		return true;
	}

	/**
	 * 定时删除odm拼图任务中重复的任务（同一个图斑多个任务，保留最新的）
	 *
	 * @return
	 */
	@Override
	public boolean deletedRepOdmTask() {
		// 查询同一个图斑多出的任务进行删除
		List<OdmTaskInfo> list = baseMapper.selectReqOdmList();
		boolean a = removeOdmTaskByList(list);
		// 删除掉odm_task_info 表中没有的任务
		boolean b = removeSuperfluousTask();
		// 删除并返回
		return a && b;
	}

	/**
	 * 删除掉 odm_task_info 表中没有的任务
	 *
	 * @return
	 */
	private boolean removeSuperfluousTask() {
		List<Integer> typeList = new ArrayList<>();
		typeList.add(WebOdmProjectIdEnum.ORT.getProjectId());
		typeList.add(WebOdmProjectIdEnum.TD.getProjectId());
		for (Integer type : typeList) {
			// 查询出所有odm_task_info 任务
			List<OdmTaskInfo> list = list();
			List<String> taskIds = list.stream().map(OdmTaskInfo::getTaskId)
				.collect(Collectors.toList());
			// 查询出webodm 中所有的任务
			// odm 任务查询 url
			String url = MessageFormat.format(OdmConstant.QUERY_TASK_API, type);
			//调用接口重启任务
			JSONArray jsonArray = sendRequest.sendGetRequestResArr(url, true);
			if (jsonArray.size() == 0) {
				log.error("没有查询到任务信息");
				return false;
			}
			List<String> nowList = new ArrayList<>();
			// 转换成taskId集合
			for (int i = 0; i < jsonArray.size(); i++) {
				nowList.add(jsonArray.getJSONObject(i).getString("id"));
			}
			// 获取 nowList 中但不在 taskIds 中的元素
			List<String> difference = nowList.stream()
				.filter(element -> !taskIds.contains(element))
				.collect(Collectors.toList());
			// 删除webodm 任务中多出的任务
			for (String taskId : difference) {
				//调用接口删除信息
				JSONObject jsonObject = sendRequest.sendPostFormData(
					MessageFormat.format(OdmConstant.REMOVE_TASK_INFO_API, type, taskId), true, null
				);
				// 返回
				if (null != jsonObject) {
					Boolean success = jsonObject.getBoolean("success");
					if (success) {
						// 异步删除对应的文件
						asyncService.deleteFileByTaskId(taskId);
					}
				}
			}
		}
		return true;
	}

	/**
	 * 定时删除odm拼图任务(航线任务已删除的)
	 *
	 * @return
	 */
	@Override
	public boolean delRepOdmTaskByNoWayJob() {
		// 查询出航线任务已经删除的任务，进行删除对于odm 任务
		List<OdmTaskInfo> list = baseMapper.selectRemWayJobList();
		// 删除并返回
		return removeOdmTaskByList(list);
	}

	/**
	 * 删除odm任务
	 *
	 * @param list
	 * @return
	 */
	private boolean removeOdmTaskByList(List<OdmTaskInfo> list) {
		// 删除
		int num1 = 0;
		int num2 = 0;
		// 遍历删除
		for (OdmTaskInfo odmTaskInfo : list) {
			odmTaskInfo.setFileDelFlag(1);
			// 数据不删除，修改数据状态
			boolean b = updateById(odmTaskInfo);
			if (b) {
				num1++;
			}
		}
		// 删除webodm任务
		num2 = removeWebodmTask(list, num2);
		// 返回
		return num1 == num2;
	}

	/**
	 * tif 图片解析画图斑面
	 *
	 * @param dkbh           地块编号
	 * @param flag           是否已完成拼图任务
	 * @param orthoimagePath 正射文件路径
	 * @return
	 */
	@Override
	public String tifParse(String dkbh, Boolean flag, String orthoimagePath) {
		log.info("tif 图片解析画图斑面,地块编号：{},是否完成拼图任务：{},正射文件路径：{}", dkbh, flag, orthoimagePath);
		if (null == flag) {
			flag = false;
		}
		if (Strings.isBlank(dkbh)) {
			log.error("地块编号不能为空");
			return null;
		}
		// 根据图斑编号 查询导出对应的正射影像信息
		OdmTaskInfoVO odmTaskInfo = baseMapper.getTbOrthoimageInfo(dkbh, null, "",OdmConstant.OTR_TASK_TYPES);
		if (Strings.isBlank(orthoimagePath)) {
			orthoimagePath = odmTaskInfo.getOrthoimagePath();
		}
		// 解析
		if (null == odmTaskInfo) {
			log.error("没有查到对应的任务");
			return null;
		}
		if (!flag && odmTaskInfo.getRunningProgress() < 1.0) {
			log.error("拼图任务尚未完成");
			return null;
		}
		if (Strings.isBlank(odmTaskInfo.getGeom())) {
			log.error("当前地块无空间面数据");
			return null;
		}
		// 将面数据转点集合
		List<Coordinate> coordinates = polygonStringToCoordinates(odmTaskInfo.getGeom());
		// 下载tif 图片，重新赋名
		// 格式化正射影像图斑画面路径
		String outPath = odmProperties.getWebodmDataBasePath() + MessageFormat.format(OdmConstant.ORTHO_TB_IMAGE_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
		// 获取路径
		String inputPath = odmTaskInfo.getBasePath() + orthoimagePath;
//		String inputPath = "C:\\Users\\Administrator\\Desktop\\其他\\无人机\\102.tif";
		//通过上传路径得到上传的文件夹
		File file = new File(outPath);
		//若目标文件夹不存在，则创建
		if (!file.exists()) {
			file.mkdirs();
		}
		//定义重新生成后的目标文件名
		outPath = outPath + "/" + dkbh + ".tif";
		log.info("tif 文件路径：{}", outPath);
		log.debug("tif 对应面数据：{}", coordinates);
//		outPath = "C:\\Users\\Administrator\\Desktop\\其他\\无人机\\out.tif";
		// 将所有点转换成地理坐标
		List<Point> pointList = ParseTifUtils.getTifPosByMoreLngLat(inputPath, new ArrayList<>(coordinates));
		log.debug("tif 地理坐标数据：{}", pointList);
		// 将所有点的地理坐标转换成像素坐标
		List<MyPoint> pixelByPointList = getPixelByPointList(inputPath, pointList);
		if (pixelByPointList.size() == 0) {
			log.error("点位转换失败");
			return null;
		}
		// 画线
		boolean drawFlag = ParseTifUtils.drawPolygonByPoints(inputPath, outPath, pixelByPointList, "tif");
		// 失败返回空
		if (!drawFlag) {
			log.error("画面失败");
			return null;
		}
		// 返回数据路径
		return MessageFormat.format(OdmConstant.ORTHO_TB_IMAGE_PATH, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId()) + "/" + dkbh + ".tif";
	}

	/**
	 * 将所有点的地理坐标转换成像素坐标
	 *
	 * @param inputPath tif 图片路径
	 * @param pointList 地理坐标集合
	 * @return
	 */
	@Override
	public List<MyPoint> getPixelByPointList(String inputPath, List<Point> pointList) {
		// 转 myPoint
		List<MyPoint> myPoints = new ArrayList<>();
		for (Point point : pointList) {
			myPoints.add(new MyPoint(point.getX(), point.getY()));
		}
		String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.PARSE_TIF_API;
		Map<String, Object> map = new HashMap<>(2);
		map.put("path", inputPath);
		map.put("source_points", myPoints);
		log.info("转换地理坐标数据：{}", map);
		// 远程调用接口获取结果
		String result = pyTifSendRequest.sendPostJsonByMap(url, map);
		JSONArray jsonArray = JSON.parseArray(result);
		// 清除原有数据进行重新赋值返回
		myPoints.clear();
		if (null != jsonArray) {
			for (int i = 0; i < jsonArray.size(); i++) {
				MyPoint myPoint = new MyPoint();
				JSONObject jsonObject = jsonArray.getJSONObject(i);
				myPoint.setX(jsonObject.getDouble("x"));
				myPoint.setY(jsonObject.getDouble("y"));
				myPoints.add(myPoint);
			}
		}
		return myPoints;
	}

	/**
	 * polygon 数据转点集合数据
	 *
	 * @param polygonString
	 * @return
	 */
	public List<Coordinate> polygonStringToCoordinates(String polygonString) {
		List<Coordinate> points = new ArrayList<>();
		String[] coordinates = polygonString.replace("POLYGON((", "").replace("))", "").split(",");
		// 遍历转换
		for (String coordinate : coordinates) {
			String[] point = coordinate.trim().split(" ");
			double x = Double.parseDouble(point[0]);
			double y = Double.parseDouble(point[1]);
			points.add(new Coordinate(x, y));
		}
		return points;
	}

	/**
	 * 处理没有 tif 画面的
	 *
	 * @return
	 */
	@Override
	public boolean handleNotParseTif() {
		// 查询没有处理tif拼图斑面的任务
		List<OdmTaskInfoVO> odmTaskInfoVOList = baseMapper.getNotParseTifOdmList(OdmConstant.OTR_TASK_TYPES);
		int size = odmTaskInfoVOList.size();
		//处理
		int num = 0;
		if (size > 0) {
			for (OdmTaskInfoVO odmTaskInfoVO : odmTaskInfoVOList) {
				// 更新
				String ortTbPath = tifParse(odmTaskInfoVO.getDkbh(), true, odmTaskInfoVO.getOrthoimagePath());
				odmTaskInfoVO.setOrtTbPath(ortTbPath);
				boolean update = updateById(odmTaskInfoVO);
				if (update) {
					// 更新正射影像tif 到 附件表
					updateOrthoimageAttach(odmTaskInfoVO);
					num++;
				}
			}
		}
		if (size == num) {
			return true;
		}
		return false;
	}

	/**
	 * 定时删除odm拼图任务(保留一个月内的数据) 按天来，动态传参
	 *
	 * @param day
	 * @return
	 */
	@Override
	public boolean delRepOdmTaskByBefOneMon(Integer day) {
		// 查询一个月之外并且没有删除的任务
		List<OdmTaskInfo> list = baseMapper.getOneMonLatOdmTask(day);
		// 删除并返回
		return updateAndRemoveWebodmTask(list);
	}

	/**
	 * 历史odm tif 数据处理
	 *
	 * @return
	 */
	@Override
	public Boolean hisOdmTaskTifDataHandler() {
		int number = 0;
		// 1. 查询所有历史 odm 任务列表
		List<OdmTaskInfoVO> list = baseMapper.getHistoryOdmTaskByTifComp(OdmConstant.OTR_TASK_TYPES);
		// 2. 遍历列表处理历史odm 图片
		for (OdmTaskInfoVO odmTaskInfo : list) {
			// 通过路径获取文件
			String path = odmTaskInfo.getBasePath() + odmTaskInfo.getOrthoimagePath();
			File file = new File(path);
			// 检查文件是否存在
			if (!file.exists()) {
				log.error("文件 {} 不存在！", path);
				continue;
			}
			String smallTargetName = "_small.jpeg";
			File smallOutFile = new File(file.getParent(), file.getName().replace(".tif", smallTargetName));
			// 检查文件是否存在
			if (smallOutFile.exists()) {
				log.error("文件已存在！", path);
				continue;
			}
			// 图片压缩
			log.info("开始压缩tif图片,路径：{}", path);
			Map<String, Object> map = new HashMap<>(1);
			map.put("ort_path", path);
			TifConvertResult tifConvertResult = tifConvertClient.tifConvJpeg(map);
			log.info("tif 图片压缩结果：{}", tifConvertResult);
		}
		return number == list.size();
	}

	/**
	 * 视频处理成3d 白膜测试
	 *
	 * @param jobId
	 * @return
	 */
	@Override
	public boolean videoToOdm(String jobId) {
		// 1. 获取视频地址
		List<String> mediaObjectKeyList = baseMapper.getMediaFileInfoByWaylineJobId(jobId);
		List<String> picAllList = new ArrayList<>();
		if (mediaObjectKeyList.size() > 0) {
			// 判断是否有再处理视频的任务，如果有则不处理，没有才处理，防止cpu,内存使用过多
			String value = bladeRedis.get(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY);
			if (!Strings.isBlank(value)) {
				log.info("已存在处理的视频，待处理完成后执行，退出当前执行");
				return false;
			}
			// 设置redis，有效时长 60 分钟
			bladeRedis.setEx(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY, "1", RedisKeyConstant.ODM_VIDEO_TO_PIC_TIME);
			// 设置缓存
			for (String objectKey : mediaObjectKeyList) {
				// 找到第一个/的位置
				int firstSlashIndex = objectKey.indexOf('/');
				if (firstSlashIndex != -1) {
					// 截取第一个/之后的部分
					objectKey = "/" + objectKey.substring(firstSlashIndex + 1);
				}
				String videoPath = "";
				// 获取运行环境信息
				String activeProfile = SpringContextUtil.getActiveProfile();
				// 拼接 url
				if (activeProfile.equals("test") || activeProfile.equals("prod")) {
					videoPath = minioDataConstant.getServerBasePath() + minioDataConstant.getBucket() + objectKey;
				}
				// 2. 读取视频，视频切图
				try {
					boolean mp4ToJpgFlag = VideoConverterUtils.mp4ToJpgRestriction(videoPath, OdmConstant.FRAME_INTERVAL);
					boolean mp4ToCreateStrFlag = VideoConverterUtils.mp4ToCreateStr(videoPath);
					if (mp4ToJpgFlag && mp4ToCreateStrFlag) {
						// 3. 切图图片经纬度、高度赋值
						String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.SET_PIC_LOCATION_API;
						String inputPath = VideoConverterUtils.getOutputPathByInputPath(videoPath);
						String srtPath = inputPath + "out.srt";
						String picPath = inputPath + "*.jpg";
						Map<String, Object> map = new HashMap<>(2);
						map.put("pic_path", picPath);
						map.put("srt_path", srtPath);
						// 远程调用接口获取结果
						String result = pyTifSendRequest.sendPostJsonByMap(url, map);
						boolean parseBoolean = Boolean.parseBoolean(result);
						// 4. 生成 webodm 任务
						if (parseBoolean) {
							// 获取图片集合
							List<String> list = getPicListByPath(inputPath, objectKey);
							// 合并数据集
							picAllList.addAll(list);
						}
					}
				} catch (IOException e) {
					// 清除缓存
					bladeRedis.del(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY);
					e.printStackTrace();
				} catch (InterruptedException e) {
					// 清除缓存
					bladeRedis.del(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY);
					e.printStackTrace();
				}
			}
			if (picAllList.size() > 0) {
				// 先创建任务
				OdmTaskInfo odmTaskInfo = new OdmTaskInfo();
				odmTaskInfo.setWaylineJobId(jobId);
				boolean b = saveOdmTaskInfo(odmTaskInfo);
				if (b) {
					createOdmTask(jobId, null, WaylineTypeEnum.ALB_COL.getType().intValue(), picAllList, odmTaskInfo.getProjectId());
				}
				// 清除缓存
				bladeRedis.del(RedisKeyConstant.ODM_VIDEO_TO_PIC_KEY);
			}
		}
		// 下面步骤需要依赖定时任务触发执行
		// 5. 通过定时任务定时获取已完成的视频任务
		// 6. 视频拼图任务完成后，处理地表模型数据，地表模型 tif 写入数据库
		// 7. 将 obj 文件处理成白膜
		// 8. 将生成的白膜转换成 3dtiles,并生成路径保存到数据库
		return true;
	}

	@Override
	public List<OdmTaskInfo> getTifDataByCoord(double longitude, double latitude) {
		return baseMapper.getTifDataByCoord(longitude, latitude);
	}

	/**
	 * 根据经纬度获取10公里内tif数据
	 *
	 * @param longitude 经度
	 * @param latitude  纬度
	 * @return
	 */
	@Override
	public List<OdmTaskInfo> getAllTifDataByCoord(double longitude, double latitude) {
		return baseMapper.getAllTifDataByCoord(longitude, latitude);
	}


	public boolean saveOdmTaskInfo(OdmTaskInfo odmTaskInfo) {
		OdmTaskInfo odmTask = getOdmTaskInfo(odmTaskInfo.getWaylineJobId());
		if (null == odmTask) {
			OdmTaskInfo jobBaseInfo = baseMapper.selectJobBaseInfo(odmTaskInfo.getWaylineJobId());
			odmTaskInfo.setType(OdmTypeEnum.ALB.getType());
			odmTaskInfo.setProjectId(WebOdmProjectIdEnum.TD.getProjectId());
			odmTaskInfo.setAreaCode(jobBaseInfo.getAreaCode());
			odmTaskInfo.setCreateUser(jobBaseInfo.getCreateUser());
			odmTaskInfo.setUpdateUser(jobBaseInfo.getUpdateUser());
			odmTaskInfo.setCreateDept(jobBaseInfo.getCreateDept());
			odmTaskInfo.setCreateTime(new Date());
			odmTaskInfo.setUpdateTime(new Date());
			boolean save = this.save(odmTaskInfo);
			return save;
		}
		return false;
	}

	/**
	 * 获取图片路径集合
	 *
	 * @param inputDir   图片完整路径目录
	 * @param object_key 视频文件的 object_key
	 * @return
	 */
	private List<String> getPicListByPath(String inputDir, String object_key) throws IOException {
		List<String> list = new ArrayList<>();
		int lastSlashIndex = object_key.lastIndexOf('.');
		if (lastSlashIndex != -1) {
			// 取  object_key 目录，取文件名作为目录
			String pathBeforeLastSlash = object_key.substring(0, lastSlashIndex);
			Path startPath = Paths.get(inputDir);
			Files.walk(startPath)
				.filter(Files::isRegularFile)
				.filter(p -> p.toString().toLowerCase().endsWith(".jpg"))
				.forEach(p -> list.add(pathBeforeLastSlash + File.separator + p.getFileName().toString()));
		}
		return list;
	}

	/**
	 * 查询地图位置上3d-tiles数据
	 *
	 * @param dto
	 * @return
	 */
	@Override
	public TreeVo getVoxGridTilesList(OdmTaskInfoQueryParam dto) {
		if (null==dto.getType()){
			// 默认展示查询白膜
			dto.setType(AttachResultTypeEnum.ALB.getType());
		}
		if (Objects.nonNull(dto.getDateEnum())) {
			TimeRange timeRange = TimeRangeUtils.getTimeRange(dto.getDateEnum());
			dto.setStartDate(timeRange.getStartTime());
			dto.setEndDate(timeRange.getEndTime());
		}
		// 设置区域code
		String areaCode = HeaderUtils.getHeader(CommonConstant.AREA_CODE).orElse(null);
		dto.setAreaCode(!StringUtils.isEmpty(dto.getAreaCode()) ? dto.getAreaCode() : areaCode);
		//所有区域数据
		Object regionResultz = RedisOpsUtils.get(CacheConstant.REGION_INFO + dto.getAreaCode());
		if (Objects.isNull(regionResultz)) {
			R<TreeVo> regionResult = sysClient.getRegionTreeByPrentCode(dto.getAreaCode());
			RedisOpsUtils.setWithExpire(CacheConstant.REGION_INFO + dto.getAreaCode(), regionResult.getData(), TimeUnit.HOURS.toSeconds(1));
			regionResultz = regionResult.getData();
		}
		// 设置区域树数据
		TreeVo data = regionResultz == null ? null : (TreeVo) regionResultz;
		// 设置格式化后的区域编号
		dto.setAreaCode(HeaderUtils.getAreaCode(dto.getAreaCode()));

		//根据条件查询所有区域对应的odm统计数据
		// List<OdmTaskStatisticsBO> odmTaskStatisticsBOList = baseMapper.getOdmTaskStatisticsByAreaCode(dto);
		//获取3d-tiles明细数据
		// List<OdmTaskTilesVo> odmTaskTilesList = baseMapper.getOdmTaskTilesList(dto);
		// 计算面积
		// List<AttachTypeStatisticsVO> attachTypeStatisticsVO = attachClient.calculateTheThreeDimensionalArea("", "", "", String.valueOf(dto.getType()), dto.getAreaCode());
		// 路径处理
//		tilesPathHandler(odmTaskTilesList);
		// 分组处理
		// Map<String, List<AttachTypeStatisticsVO>> odmTaskTilesMap = Streams.groupBy(attachTypeStatisticsVO, AttachTypeStatisticsVO::getAreaCode);
		//县下面的所有数量 key=区域code,value =数量
		// Map<String, Double> map = Streams.toMap(attachTypeStatisticsVO, AttachTypeStatisticsVO::getAreaCode, AttachTypeStatisticsVO::getArea);
		//县区域下的所有3D-TILES数量

		//根据条件查询所有区域对应的odm统计数据
		List<OdmTaskStatisticsBO> odmTaskStatisticsBOList = baseMapper.getOdmTaskStatisticsByAreaCode(dto);
		//获取3d-tiles明细数据
		List<OdmTaskTilesVo> odmTaskTilesList = baseMapper.getOdmTaskTilesList(dto);
		// 路径处理
//		tilesPathHandler(odmTaskTilesList);
		List<AttachTypeStatisticsVO> attachTypeStatisticsVO = attachClient.calculateTheThreeDimensionalArea("", "", "", String.valueOf(dto.getType()), dto.getAreaCode());
		// 分组处理
		Map<String, List<OdmTaskTilesVo>> odmTaskTilesMap = Streams.groupBy(odmTaskTilesList, OdmTaskTilesVo::getAreaCode);
		//县下面的所有数量 key=区域code,value =数量
		// Map<String, Integer> map = Streams.toMap(odmTaskStatisticsBOList, OdmTaskStatisticsBO::getDictKey, OdmTaskStatisticsBO::getNum);
		Map<String, Double> map = Streams.toMap(attachTypeStatisticsVO, AttachTypeStatisticsVO::getAreaCode, AttachTypeStatisticsVO::getArea);
		//县区域下的所有3D-TILES数量

		TreeVo treeVo = TreeUtils.buildTreeVo(data, map, odmTaskTilesMap);
		// 返回
		return treeVo;
	}

	/**
	 * tiles 路径处理
	 *
	 * @param odmTaskTilesList
	 */
	private void tilesPathHandler(List<OdmTaskTilesVo> odmTaskTilesList) {
		if (odmTaskTilesList.size() > 0) {
			// 获取运行环境信息
			String activeProfile = SpringContextUtil.getActiveProfile();
			// 先拼接数据
			for (OdmTaskTilesVo odmTaskTilesVo : odmTaskTilesList) {
				if (!Strings.isBlank(odmTaskTilesVo.getTilesPath())) {
					// 拼接 url
					odmTaskTilesVo.setTilesPath(odmProperties.getDomainUrl() + odmTaskTilesVo.getTilesPath());
				}
			}
		}
	}

	/**
	 * 查询地图位置上3d-tiles数据-单机巢
	 *
	 * @param dto
	 * @return
	 */
	@Override
	public List<OdmTaskTilesVo> getVoxGridTilesListBySinglePlayer(OdmTaskInfoQueryParam dto) {
		List<OdmTaskTilesVo> odmTaskTilesList = new ArrayList<>();
		if (Strings.isBlank(dto.getDeviceSn())) {
			return odmTaskTilesList;
		}
		if(null==dto.getType()){
			// 没传默认给3 白膜
			dto.setType(AttachResultTypeEnum.ALB.getType());
		}
		odmTaskTilesList = baseMapper.getOdmTaskTilesList(dto);
		// 路径处理
//		tilesPathHandler(odmTaskTilesList);
		return odmTaskTilesList;
	}

	/**
	 * 历史 odm 新增相关字段数据补充
	 *
	 * @return
	 */
	@Override
	public int historyOdmTaskDataHandler() {
		// 获取运行环境信息
		String activeProfile = SpringContextUtil.getActiveProfile();
		// 查询没有设备编号的数据，进行补充
//		List<OdmTaskInfo> list = baseMapper.getNoDeviceOdmTaskList();
		List<OdmTaskInfoVO> list = baseMapper.getNoGeomOdmTaskList();
		for (OdmTaskInfoVO odmTaskInfo : list) {
			odmTaskInfo.setGeom(getGeom(odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId(), activeProfile));
			// 更新
			baseMapper.updateOdmTaskGeomInfoById(odmTaskInfo);
		}
		return 0;
	}

	/**
	 * 测试远程调用资源模块
	 *
	 * @return
	 */
	@Override
	public Boolean testToResource(MultipartFile file) {
		Attach attach = new Attach();
		attach.setName("/software/data/odm-data/docker/volumes/webodm_appmedia/_data/project/3/task/a34ad90f-bb45-4c93-b022-597c3a86d60c/assets/odm_orthophoto/odm_orthophoto.tif");
		Boolean aBoolean = attachClient.saveAttachInfo(attach);
		try {
			BladeFile test = attachClient.putFile(file, "test");
		} catch (IOException e) {
			e.printStackTrace();
		}
		return aBoolean;
	}

	/**
	 * 更新三维白膜信息到  附件表
	 *
	 * @return
	 */
	@Override
	public R updateVoxGridTilesToAttach() {
		int count = 0;
		// 查询已完成的任务中没有将三维白膜 信息同步到 附件表的信息
		List<OdmTaskInfoVO> list = baseMapper.getNoSaveTilesAttachOdmTaskInfoList();
		// 遍历将三维白膜 信息同步到附件表
		for (OdmTaskInfoVO odmTaskInfo : list) {
			Boolean flag = update3dTilesAttach(odmTaskInfo, odmTaskInfo.getVoxGridTilesPath());
			if (flag) {
				count++;
			}
		}
		return R.status(count == list.size());
	}

	/**
	 * 3d白膜部分生成失败补充
	 *
	 * @return
	 */
	@Override
	public void tilesSup() {
		OdmTaskInfoVO odmTaskInfoVO = new OdmTaskInfoVO();
		odmTaskInfoVO.setType(OdmTypeEnum.ALB.getType());
		handleTiles(odmTaskInfoVO);
	}

	/**
	 * 实景三维生成失败补充
	 * @return
	 */
	@Override
	public void liveTilesSup() {
		OdmTaskInfoVO odmTaskInfoVO = new OdmTaskInfoVO();
		odmTaskInfoVO.setType(OdmTypeEnum.TILT.getType());
		handleLiveTiles(odmTaskInfoVO);
	}

	/**
	 * 3d白膜部分生成失败补充
	 *
	 * @param odmTaskInfo
	 * @return
	 */
	@Override
	public void tilesSupByParam(OdmTaskInfoVO odmTaskInfo) {
		handleTiles(odmTaskInfo);
	}

	/**
	 * 补充处理白膜
	 *
	 * @param odmTaskInfoVO
	 */
	public void handleTiles(OdmTaskInfoVO odmTaskInfoVO) {
		// 设置地形文件（处理耗时较长）时配置 redis,防止重复调用
		String value = bladeRedis.get(RedisKeyConstant.ODM_TIELS_KEY);
		if (!Strings.isBlank(value)) {
			return;
		}
		// 查询状态已经完成已处理过的，然后没有生成出白膜的任务
		List<OdmTaskInfoVO> list = baseMapper.getNotCreateTilesTask(odmTaskInfoVO);
		// 获取运行环境信息
		String activeProfile = SpringContextUtil.getActiveProfile();
		// 遍历处理
		for (OdmTaskInfoVO odmTaskInfo : list) {
			log.info("开始补充处理三维白膜数据，任务id:{}", odmTaskInfo.getTaskId());
			// 设置缓存
			bladeRedis.setEx(RedisKeyConstant.ODM_TIELS_KEY, "1", RedisKeyConstant.DEFAULT_TIME);
			setPointCloudTo3dTilesPath(odmTaskInfo, activeProfile);
			log.info("补充处理三维白膜数据结束，任务id:{}，处理后白膜路径：{}", odmTaskInfo.getTaskId(), odmTaskInfo.getVoxGridTilesPath());
			if (!Strings.isBlank(odmTaskInfo.getVoxGridTilesPath())) {
				boolean flag = false;
				if (Strings.isBlank(odmTaskInfo.getGeom())) {
					// 更新
					flag = updateById(odmTaskInfo);
				} else {
					// 手动更新
					int update = baseMapper.updateOdmTaskGeomInfoById(odmTaskInfo);
					flag = update > 0 ? true : false;
				}
				if (flag) {
					log.info("开始更新三维白膜数据到附件表，任务id:{}", odmTaskInfo.getTaskId());
					update3dTilesAttach(odmTaskInfo, odmTaskInfo.getVoxGridTilesPath());
				}
			}
			bladeRedis.del(RedisKeyConstant.ODM_TIELS_KEY);
		}
	}

	/**
	 * 补充处理实景三维
	 * @param odmTaskInfoVO
	 */
	public void handleLiveTiles(OdmTaskInfoVO odmTaskInfoVO) {
		// 设置地形文件（处理耗时较长）时配置 redis,防止重复调用
		String value = bladeRedis.get(RedisKeyConstant.ODM_LIVE_TIELS_KEY);
		if (!Strings.isBlank(value)) {
			return;
		}
		// 查询状态已经完成已处理过的，然后没有生成出白膜的任务
		List<OdmTaskInfoVO> list = baseMapper.getNotCreateTilesTask(odmTaskInfoVO);
		// 获取运行环境信息
		String activeProfile = SpringContextUtil.getActiveProfile();
		// 遍历处理
		for (OdmTaskInfoVO odmTaskInfo : list) {
			log.info("开始补充处理实景倾斜三维数据，任务id:{}", odmTaskInfo.getTaskId());
			// 设置缓存
			bladeRedis.setEx(RedisKeyConstant.ODM_LIVE_TIELS_KEY, "1", RedisKeyConstant.DEFAULT_TIME);
			// 远程调用服务设置三维倾斜路径
			setObjTo3dTilesPath(odmTaskInfo, activeProfile);
			log.info("补充处理实景倾斜三维数据结束，任务id:{}，处理后实景倾斜三维路径：{}", odmTaskInfo.getTaskId(), odmTaskInfo.getVoxGridTilesPath());
			if (!Strings.isBlank(odmTaskInfo.getTilesPath())) {
				boolean flag = false;
				if (Strings.isBlank(odmTaskInfo.getGeom())) {
					// 更新
					flag = updateById(odmTaskInfo);
				} else {
					// 手动更新
					int update = baseMapper.updateOdmTaskGeomInfoById(odmTaskInfo);
					flag = update > 0 ? true : false;
				}
				if (flag) {
					log.info("开始更新实景倾斜三维数据到附件表，任务id:{}", odmTaskInfo.getTaskId());
					update3dTilesAttach(odmTaskInfo, odmTaskInfo.getTilesPath());
				}
			}
			bladeRedis.del(RedisKeyConstant.ODM_LIVE_TIELS_KEY);
		}
	}

	@Override
	public TifParseResponse tifParseNew(TifParseRequest request) {
		String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.ANALYZE_TIF_ELEVATION;
		Map<String, Object> map = convertTifParseRequestToMap(request);
		// 远程调用接口获取结果
		log.info("开始调用 tif 解析接口，参数：{}", map);
		String result = pyTifSendRequest.sendPostJsonByMap(url, map);
		log.info("tif 解析接口返回结果：{}", result);
		TifParseResponse tifParseResponse = JSON.parseObject(result, TifParseResponse.class);

		return tifParseResponse;
	}

	// 将 TifParseRequest 对象转换为 Map
	private Map<String, Object> convertTifParseRequestToMap(TifParseRequest request) {
		Map<String, Object> map = new HashMap<>();
		map.put("tif_paths", request.getTif_paths());
		map.put("start_lat", request.getStart_lat());
		map.put("start_lon", request.getStart_lon());
		map.put("end_lat", request.getEnd_lat());
		map.put("end_lon", request.getEnd_lon());
		map.put("interval", request.getInterval());
		return map;
	}

	@Override
	public List<PointParam> waylineFlightPathPlanning(List<PointParam> param) {
		String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.WAYLINE_PLAN_API;
		List<Map<String, Object>> map = convertPointParamsToFlightPathList(param);
		// 远程调用接口获取结果
		log.info("开始调用网格航线接口，参数：{}", map);
		String result = pyTifSendRequest.planFlightPath(url, map);
		log.info("网格航线接口返回结果：{}", result);

		// 处理返回的JSON字符串，去除外层的引号并解析转义字符
		if (result != null && !result.isEmpty()) {
			// 去除首尾的引号
			if (result.startsWith("\"") && result.endsWith("\"")) {
				result = result.substring(1, result.length() - 1);
			}
			// 处理转义字符
			result = result.replace("\\\"", "\"");
		}
		List<PointParam> pointParams = new ArrayList<>();

		if (result == null || result.isEmpty()) {
			return pointParams;
		}

		try {
			// 解析JSON数组
			JSONArray jsonArray = JSONArray.parseArray(result);

			for (int i = 0; i < jsonArray.size(); i++) {
				JSONObject jsonObject = jsonArray.getJSONObject(i);

				// 创建PointParam对象
				PointParam pointParam = new PointParam();
				pointParam.setLongitude(jsonObject.getDouble("longitude"));
				pointParam.setLatitude(jsonObject.getDouble("latitude"));
				pointParam.setExecuteHeight(jsonObject.getDouble("height"));
				pointParam.setIsTarget(jsonObject.getInteger("isTarget"));
				pointParam.setOriginalIndex(jsonObject.getInteger("originalIndex"));

				// 设置默认值
				pointParam.setWaypointSpeed(10.0); // 默认速度
				pointParam.setClickTiles(1); // 默认在模型上
				pointParam.setHoverTime(0.0); // 默认悬停时间

				pointParams.add(pointParam);
			}
		} catch (Exception e) {
			log.error("解析JSON字符串失败：{}", e.getMessage());
			e.printStackTrace();
		}

		return pointParams;
	}


	@Override
	public void generateGridTask() {
		log.info("开始生成网格任务");
		String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.GRID_TASK_API;
		// 远程调用接口获取结果
		pyTifSendRequest.sendGetByMap(url);
		log.info("生成网格任务结束");
	}

	/**
	 * 保存禁飞区面数据
	 *
	 * @param height  高度
	 * @param geoData geo 数据
	 * @return
	 */
	@Override
	public Map<String, Object> saveMultipolygonInfo(Double height, String geoData) {
		try {
			String url = pyToolsServiceProperties.getPyToolsService() + TifConstant.SAVE_MULTIPOLYGON_API;
			// area1 = "[[115.884897,28.61798],[115.881343,28.613184],[115.887823,28.612999],[115.884897,28.61798],[115.884897,28.61798]]";
			// area2 = "MULTIPOLYGON(((113.0 23.0,113.0 24.0,114.0 24.0,114.0 23.0,113.0 23.0)))";
			Map<String, Object> map = new HashMap<>();
			map.put("height", String.valueOf(height));
			map.put("multipolygon_wkt", geoData);
			// 远程调用接口获取结果
			String responseJson = pyTifSendRequest.sendPostJsonByMap(url, map);
			String idsIfSuccess = getIdsIfSuccess(responseJson);
			log.info("保存禁飞区面数据成功，返回的IDs为：{}", idsIfSuccess);
			if (idsIfSuccess == null || idsIfSuccess.isEmpty()) {
				log.error("保存禁飞区面数据失败");
				throw new RuntimeException("保存禁飞区面数据失败");
			}
			Map<String, Object> resultMap = new HashMap<>();
			resultMap.put("ids", idsIfSuccess);
			return resultMap;
		} catch (Exception e) {
			log.error("保存禁飞区面数据失败: {}", e);
			throw new RuntimeException(e);
		}
	}

	/**
	 * 判断操作是否成功，如果成功则返回IDs，否则返回空字符串
	 *
	 * @param responseJson 响应的JSON字符串
	 * @return 成功时返回IDs，失败时返回空字符串
	 */
	public String getIdsIfSuccess(String responseJson) {
		try {
			JSONObject jsonObject = JSON.parseObject(responseJson);
			String status = jsonObject.getString("status");

			if ("success".equals(status)) {
				JSONArray insertedGids = jsonObject.getJSONArray("inserted_gids");
				if (insertedGids != null && !insertedGids.isEmpty()) {
					// 将数组转换为逗号分隔的字符串
					StringBuilder idsBuilder = new StringBuilder();
					for (int i = 0; i < insertedGids.size(); i++) {
						if (i > 0) {
							idsBuilder.append(",");
						}
						idsBuilder.append(insertedGids.get(i));
					}
					return idsBuilder.toString();
				}
			}
		} catch (Exception e) {
			log.error("解析JSON响应时出错: {}", e.getMessage());
		}
		return "";
	}

	/**
	 * 将PointParam列表按相邻点分组，例如(1,2)、(2,3)、(3,4)等
	 *
	 * @param request PointParam列表
	 * @return 分组后的列表，每组包含两个相邻的点
	 */
	private List<List<PointParam>> groupPointParamsInPairs(List<PointParam> request) {
		List<List<PointParam>> groupedPoints = new ArrayList<>();

		if (request == null || request.size() < 2) {
			return groupedPoints;
		}

		for (int i = 0; i < request.size() - 1; i++) {
			List<PointParam> pair = new ArrayList<>();
			pair.add(request.get(i));
			pair.add(request.get(i + 1));
			groupedPoints.add(pair);
		}

		return groupedPoints;
	}

	/**
	 * 将PointParam列表转换为用于飞行路径规划的Map列表
	 *
	 * @param request PointParam列表
	 * @return 转换后的Map列表
	 */
	private List<Map<String, Object>> convertPointParamsToFlightPathList(List<PointParam> request) {
		List<Map<String, Object>> flightPathList = new ArrayList<>();

		// 将相邻点分组
		List<List<PointParam>> groupedPoints = groupPointParamsInPairs(request);

		// 转换每组点为Map格式
		for (List<PointParam> pair : groupedPoints) {
			if (pair.size() == 2) {
				PointParam startPoint = pair.get(0);
				PointParam endPoint = pair.get(1);

				Map<String, Object> segmentMap = new HashMap<>();
				segmentMap.put("start_latitude", startPoint.getLatitude());
				segmentMap.put("start_longitude", startPoint.getLongitude());
				segmentMap.put("start_height", startPoint.getExecuteHeight());
				segmentMap.put("start_index", startPoint.getOriginalIndex());
				segmentMap.put("end_latitude", endPoint.getLatitude());
				segmentMap.put("end_longitude", endPoint.getLongitude());
				segmentMap.put("end_height", endPoint.getExecuteHeight());
				segmentMap.put("end_index", endPoint.getOriginalIndex());

				flightPathList.add(segmentMap);
			}
		}

		return flightPathList;
	}

	/**
	 * 获取历史 obj 网格数据
	 *
	 * @return
	 */
	@Override
	public int getHisObjGridData() {
		// 查询已经生成的obj 网格白马数据
		List<OdmTaskInfoVO> list = baseMapper.getHistoryOdmTaskListByTifComp();
		String basePath = "D:/obj_grid/";
		for (OdmTaskInfoVO odmTaskInfo : list) {
			// 拼接obj 网格路径
			String objPath = "https://wrj.shuixiongit.com/aisky-webodm-vol";
			String objBasePath = "/webodm_appmedia/_data/project/{0}/task/{1}/assets/odm_texturing/odm_textured_model_geo_conv_vox_grid.obj";
			String posiBasePath = "/webodm_appmedia/_data/project/{0}/task/{1}/assets/odm_georeferencing/odm_georeferencing_model_geo.txt";
			// 写入 obj 网格
			String objDownUrl = objPath + MessageFormat.format(objBasePath, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());

			log.info("开始下载 obj 网格数据，任务id:{}，下载路径：{}", odmTaskInfo.getTaskId(), objDownUrl);
			downloadFile(objDownUrl, basePath + odmTaskInfo.getTaskId() + "/" + "odm_grid.obj");
			// 拼接坐标文件路径
			String posiDownUrl = objPath + MessageFormat.format(posiBasePath, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());
			// 下载坐标文件
			log.info("开始下载 obj 坐标文件，任务id:{}，下载路径：{}", odmTaskInfo.getTaskId(), objDownUrl);
			String posiSavePath = basePath + odmTaskInfo.getTaskId() + "/" + "position.txt";
			downloadFile(posiDownUrl, posiSavePath);
			// 调用接口转换坐标
			setTilesPostion(posiSavePath);
		}
		return 0;
	}

	/**
	 * 下载文件并保存到指定路径
	 */
	private boolean downloadFile(String fileUrl, String saveFilePath) {
		HttpsURLConnection connection = null;
		InputStream in = null;
		FileOutputStream out = null;

		try {
			// 确保目标文件的父目录存在
			File saveFile = new File(saveFilePath);
			if (saveFile.exists()) {
				return true;
			}
			File parentDir = saveFile.getParentFile();
			if (parentDir != null && !parentDir.exists()) {
				// 递归创建所有不存在的父目录
				boolean dirsCreated = parentDir.mkdirs();
				if (!dirsCreated) {
					System.out.println("无法创建目录: " + parentDir.getAbsolutePath());
					return false;
				}
			}

			URL url = new URL(fileUrl);
			connection = (HttpsURLConnection) url.openConnection();
			connection.setRequestMethod("GET");
			connection.setConnectTimeout(5000);
			connection.setReadTimeout(10000);

			// 检查响应码
			if (connection.getResponseCode() != HttpsURLConnection.HTTP_OK) {
				System.out.println("下载失败，响应码: " + connection.getResponseCode());
				return false;
			}

			// 读取输入流并写入文件
			in = connection.getInputStream();
			out = new FileOutputStream(saveFilePath);

			byte[] buffer = new byte[1024];
			int bytesRead;
			while ((bytesRead = in.read(buffer)) != -1) {
				out.write(buffer, 0, bytesRead);
			}

			return true;

		} catch (Exception e) {
			e.printStackTrace();
			return false;
		} finally {
			// 关闭资源
			try {
				if (out != null) out.close();
				if (in != null) in.close();
				if (connection != null) connection.disconnect();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 调用 api 转换白膜中心点坐标
	 *
	 * @param filePath
	 */
	private void setTilesPostion(String filePath) {
		log.info("开始处理倾斜数据");
		// obj 转体素化网格 3d-tiles
		String objPositionConvUrl = pyToolsServiceProperties.getPyToolsService() + TifConstant.OBJ_POSITION_CONV_API;
		Map<String, Object> map = new HashMap<>(2);
		map.put("file_path", filePath);
		// 远程调用接口获取结果
		String result = pyTifSendRequest.sendPostJsonByMap(objPositionConvUrl, map);
		log.info("结果：{}", result);
	}

	/**
	 * 处理历史已飞的点云提取建筑生成白膜
	 *
	 * @return
	 */
	@Override
	public Boolean handleHistoryPointCloudTo3dtiles() {
		// 判断是否有再处理任务，如果有则不处理，没有才处理，防止cpu,内存使用过多
		String value = bladeRedis.get(RedisKeyConstant.ODM_POINT_CLOUD_KEY);
		if (!Strings.isBlank(value)) {
			log.info("已存在处理点云");
			return false;
		}
		// 设置redis，有效时长 60*2 分钟
		bladeRedis.setEx(RedisKeyConstant.ODM_POINT_CLOUD_KEY, "1", RedisKeyConstant.ODM_POINT_CLOUD_TIME);
		// 查询已经生成的obj 网格白膜数据
		List<OdmTaskInfoVO> list = baseMapper.getHistoryOdmTaskListByTifComp();
		// 获取运行环境信息
		String activeProfile = SpringContextUtil.getActiveProfile();
		// 每次取一个处理
		OdmTaskInfoVO odmTaskInfo = list.get(0);
		// 调用接口处理
		setPointCloudTo3dTilesPath(odmTaskInfo, activeProfile);
		// 通过路径获取文件
		String path = odmProperties.getWebodmDataBasePath() + odmTaskInfo.getVoxGridTilesPath();
		File file = new File(path);
		// 检查文件是否存在
		if (!file.exists()) {
			log.error("三维白膜/倾斜数据文件 {} 不存在！", path);
			return false;
		}
		// 处理完成后更新数据
		Attach attach = new Attach();
		// 此处查询的id 为 附件表的id
		attach.setId(odmTaskInfo.getId());
		// 计算设置文件大小
		attach.setAttachSize(file.length());
		// 设置文件路径，链接等
		attach.setDomainUrl(odmProperties.getDomainUrl());
		attach.setLink(odmProperties.getDomainUrl() + odmTaskInfo.getVoxGridTilesPath());
		attach.setName(path);
		attach.setOriginalName(path);

		// 设置类型-三维白膜
		// 测试用，临时用,用后需要手动数据库修改
		attach.setResultType(null);

		log.info("发起远程调用保存三维白膜/倾斜附件信息,tif 路径：{}", path);
		Boolean isSaveAttach = attachClient.saveAttachInfo(attach);
		// 结束后删除redis
		bladeRedis.del(RedisKeyConstant.ODM_POINT_CLOUD_KEY);
		return isSaveAttach;
	}

	/**
	 * 获取历史 点云数据
	 *
	 * @return
	 */
	@Override
	public int getHisPointCloudData() {
		// 查询已经生成的obj 网格白马数据
		List<OdmTaskInfoVO> list = baseMapper.getHistoryOdmTaskListByTifComp();
		String basePath = "E:\\temp\\webodm\\pointcloud\\";
		for (OdmTaskInfoVO odmTaskInfo : list) {
			// 拼接点云路径
			String pointCloudPath = "https://wrj.shuixiongit.com/aisky-webodm-vol";
			String pointCloudBasePath = "/webodm_appmedia/_data/project/{0}/task/{1}/assets/odm_georeferencing/odm_georeferenced_model.laz";
			// 写入 obj 网格
			String pointCloudDownUrl = pointCloudPath + MessageFormat.format(pointCloudBasePath, odmTaskInfo.getProjectId(), odmTaskInfo.getTaskId());

			log.info("开始下载点云laz数据，任务id:{}，下载路径：{}", odmTaskInfo.getTaskId(), pointCloudDownUrl);
			downloadFile(pointCloudDownUrl, basePath + odmTaskInfo.getTaskId() + "/" + "odm_georeferencing_model.laz");
		}
		return 0;
	}

	@Override
	public Boolean deleteGrid(String ids) {
		// 检查参数是否为空
		if (StringUtils.isEmpty(ids)) {
			log.warn("传入的ids参数为空，无法执行删除操作");
			return false;
		}
		try {
			String url = getTifServiceBaseUrl() + TifConstant.DELETE_DELETE_GRID_API;
			String[] split = ids.split(",");
			Map<String, Object> map = new HashMap<>();
			map.put("gid_array", split);
			// 远程调用接口获取结果
			String responseJson = pyTifSendRequest.sendPostJsonByMap(url, map);
			// 解析响应并安全获取状态值
			if (StringUtils.isEmpty(responseJson)) {
				log.warn("从远程接口接收到空响应");
				return false;
			}
			JSONObject jsonObject = JSON.parseObject(responseJson);
			Boolean status = jsonObject != null ? jsonObject.getBoolean("status") : null;
			return status != null ? status : false;
		} catch (Exception e) {
			log.error("删除网格数据时发生异常: ", e);
			return false;
		}
	}

	/**
	 * 将机场地形高度初始化参数缓存到Redis队列中
	 *
	 * @param centerLon 经度
	 * @param centerLat 纬度
	 * @param dockSn    机场序列号
	 * @return 缓存结果 1-成功 0-失败
	 */
	@Override
	public Integer cacheAirportTerrainHeightParams(String centerLon, String centerLat, String dockSn) {
		try {
			// 检查机场参数是否已缓存
			if (bladeRedis.exists(RedisKeyConstant.AIRPORT + dockSn)) {
				return 0;
			}
			// 设置机场参数缓存有效期 100 分钟
			bladeRedis.setEx(RedisKeyConstant.AIRPORT + dockSn, dockSn, 100 * 60L);
			// 构造缓存key
			String cacheKey = RedisKeyConstant.AIRPORT_TERRAIN_HEIGHT;
			// 构造缓存数据
			Map<String, String> cacheData = new HashMap<>();
			cacheData.put("center_lon", centerLon);
			cacheData.put("center_lat", centerLat);
			cacheData.put("dock_sn", dockSn);
			// 将数据存储到Redis列表中
			bladeRedis.lPush(cacheKey, JSON.toJSONString(cacheData));
			log.info("机场地形高度参数已缓存到Redis队列，key: {}", cacheKey);

			return 1;
		} catch (Exception e) {
			log.error("缓存机场地形高度参数到Redis时发生异常: ", e);
		}
		return 0;
	}

	/**
	 * 从Redis队列中获取并移除第一个机场地形高度参数
	 *
	 * @return 机场地形高度参数
	 */
	@Override
	public Map<String, String> getAirportTerrainHeightParams() {
		try {
			// 获取队列key
			String cacheKey = RedisKeyConstant.AIRPORT_TERRAIN_HEIGHT;
			// 从队列左侧获取并移除第一个元素
			Object dataObj = bladeRedis.lPop(cacheKey);
			if (dataObj != null) {
				log.info("成功获取并移除机场地形高度参数，key: {}", JSON.toJSON(dataObj));
				// 如果是字符串，则尝试解析为JSON
				String dataStr = JSON.toJSONString(dataObj);
				JSONArray array = JSON.parseArray(dataStr);
				String string = array.get(0).toString();
				// 移除可能的引号和转义字符
				Map<String, String> data = JSON.parseObject(string, Map.class);
				log.info("成功获取并移除机场地形高度参数，key: {}", cacheKey);
				return data;
			} else {
				log.info("机场地形高度参数队列为空，key: {}", cacheKey);
			}
		} catch (Exception e) {
			log.error("获取并移除机场地形高度参数时发生异常: ", e);
		}
		return new HashMap<>();
	}


	/**
	 * 初始化机场高程
	 *
	 * @param centerLon
	 * @param centerLat
	 * @param dockSn
	 * @return
	 */
	@Override
	public Boolean initAirportTerrainHeight(String centerLon, String centerLat, String dockSn) {
		try {
			String url = getTifServiceBaseUrl() + TifConstant.INIT_AIRPORT_TERRAIN_API;
			String areaCodePrefix = getDistrictCodeByLocation(Double.parseDouble(centerLon), Double.parseDouble(centerLat));
			log.info("初始化机场高程，区域前缀：{}", areaCodePrefix);
			String demInfoPath = baseMapper.getDemInfo(areaCodePrefix);
			if (demInfoPath == null) {
				log.warn("未找到匹配的DEM信息，请检查DEM信息表");
				return false;
			}
			Map<String, Object> map = new HashMap<>();
			map.put("center_lon", centerLon);
			map.put("center_lat", centerLat);
			map.put("tif_paths", demInfoPath);
			map.put("dock_sn", dockSn);
			// 远程调用接口获取结果
			String responseJson = pyTifSendRequest.sendPostJsonByMap(url, map);
			// 解析响应并安全获取状态值
			if (StringUtils.isEmpty(responseJson)) {
				log.warn("从远程接口接收到空响应");
				return false;
			}
			JSONObject jsonObject = JSON.parseObject(responseJson);
			Boolean status = jsonObject != null ? jsonObject.getBoolean("status") : null;
			return status != null ? status : false;
		} catch (Exception e) {
			log.error("初始化机场高程发生异常: ", e);
			return false;
		}
	}

	/**
	 * 获取航点最大高度
	 *
	 * @param mapLatLng
	 * @return
	 */
	@Override
	public Integer getWaylineMaxTerrainHeight(List<MapLatLng> mapLatLng) {
		try {
			String url = getTifServiceBaseUrl() + TifConstant.GET_AIRLINE_MAX_HEIGHT_API;
			Map<String, Object> map = new HashMap<>();
			map.put("mapLatLng", mapLatLng);
			// 远程调用接口获取结果
			String responseJson = pyTifSendRequest.sendPostJsonByMap(url, map);
			// 解析响应并安全获取状态值
			if (StringUtils.isEmpty(responseJson)) {
				log.warn("从远程接口接收到空响应");
				return 0;
			}
			JSONObject jsonObject = JSON.parseObject(responseJson);
			Boolean status = jsonObject != null ? jsonObject.getBoolean("status") : null;
			return status != null ? jsonObject.getInteger("max_height") : 0;
		} catch (Exception e) {
			log.error("获取航点最大高度发生异常: ", e);
			return 0;
		}
	}

	/**
	 * 删除机场地形数据
	 *
	 * @param dockSn
	 * @return
	 */
	@Override
	public Integer deleteAirportTerrainHeight(String dockSn) {
		try {
			String url = getTifServiceBaseUrl() + TifConstant.DELETE_AIRPORT_TERRAIN_API;
			Map<String, Object> map = new HashMap<>();
			map.put("dock_sn", dockSn);
			// 远程调用接口获取结果
			String responseJson = pyTifSendRequest.sendPostJsonByMap(url, map);
			// 解析响应并安全获取状态值
			if (StringUtils.isEmpty(responseJson)) {
				log.warn("从远程接口接收到空响应");
				return 0;
			}
			JSONObject jsonObject = JSON.parseObject(responseJson);
			Boolean status = jsonObject != null ? jsonObject.getBoolean("status") : null;
			return status != null ? jsonObject.getInteger("total_count") : 0;
		} catch (Exception e) {
			log.error("删除机场地形数据发生异常: ", e);
			return 0;
		}
	}

	/**
	 * 根据环境获取对应的TIF服务基础URL
	 *
	 * @return
	 */
	private String getTifServiceBaseUrl() {
		String baseUrl = pyToolsServiceProperties.getPyToolsService();
		return baseUrl;
	}

	/**
	 * 根据经纬度获取行政区划信息
	 *
	 * @param longitude 经度
	 * @param latitude  纬度
	 * @return 行政区划信息
	 */
	public Map<String, String> getDistrictInfoByLocation(double longitude, double latitude) {
		// 使用高德地图工具类获取行政区划信息
		String location = longitude + "," + latitude;
		JSONObject result = AmapUtils.searchByLatLng(location);

		Map<String, String> districtInfo = new HashMap<>();
		if (result != null && "1".equals(result.getString("status"))) {
			JSONObject regeocode = result.getJSONObject("regeocode");
			if (regeocode != null) {
				JSONObject addressComponent = regeocode.getJSONObject("addressComponent");
				if (addressComponent != null) {
					districtInfo.put("province", addressComponent.getString("province"));
					districtInfo.put("city", addressComponent.getString("city"));
					districtInfo.put("district", addressComponent.getString("district"));
					districtInfo.put("adcode", addressComponent.getString("adcode"));
					districtInfo.put("township", addressComponent.getString("township"));
					districtInfo.put("formatted_address", regeocode.getString("formatted_address"));
				}
			}
		}
		return districtInfo;
	}

	/**
	 * 根据经纬度获取行政区划编码
	 *
	 * @param longitude 经度
	 * @param latitude  纬度
	 * @return 行政区划编码
	 */
	public String getDistrictCodeByLocation(double longitude, double latitude) {
		Map<String, String> districtInfo = getDistrictInfoByLocation(longitude, latitude);
		String adcode = districtInfo.get("adcode");
		if (adcode != null && adcode.length() >= 3) {
			return adcode.substring(0, 2);
		}
		return adcode;
	}

}