package org.sxkj.resource.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.CollectionUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.sxkj.common.model.Pagination;
import org.sxkj.common.model.PaginationData;
import org.sxkj.common.model.ResponseResult;
import org.sxkj.common.utils.FileTypeUtils;
import org.sxkj.resource.builder.DevicePermissionBuilder;
import org.sxkj.resource.entity.MediaFileEntity;
import org.sxkj.resource.mapper.AttachMapper;
import org.sxkj.resource.mapper.IFileMapper;
import org.sxkj.resource.model.EventHistoryDto;
import org.sxkj.resource.model.MediaFileDTO;
import org.sxkj.resource.model.MediaJobDTO;
import org.sxkj.resource.model.SearchMediaParam;
import org.sxkj.resource.service.IFileService;
import org.sxkj.resource.vo.MediaFileCountVO;
import org.sxkj.resource.vo.MediaFileVO;
import org.sxkj.system.cache.SysCache;

import java.io.File;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;


/**
 * @author raojiangang
 * @version 0.2
 * @date 2021/12/9
 */
@Service
@Transactional
@Slf4j
public class FileServiceImpl implements IFileService {

	@Autowired
	private IFileMapper mapper;

	@Value("${mio.out-net-file-address}")
	private String fileAddress;
	@Value("${mio.bucket}")
	private String bucket;
	@Autowired
	private AttachMapper attachMapper;
	@Autowired
	private DevicePermissionBuilder permissionBuilder;


	private Optional<MediaFileEntity> getMediaByFingerprint(String workspaceId, String fingerprint) {
		MediaFileEntity fileEntity = mapper.selectOne(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getWorkspaceId, workspaceId)
			.eq(MediaFileEntity::getFingerprint, fingerprint)
			.eq(MediaFileEntity::getIsDelete, 0)
			.last("limit 1"));
		return Optional.ofNullable(fileEntity);
	}

	private Optional<MediaFileEntity> getMediaByFileId(String workspaceId, String fileId) {
		MediaFileEntity fileEntity = mapper.selectOne(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getWorkspaceId, workspaceId)
			.eq(MediaFileEntity::getFileId, fileId));
		return Optional.ofNullable(fileEntity);
	}

	@Override
	public Boolean checkExist(String workspaceId, String fingerprint) {
		return this.getMediaByFingerprint(workspaceId, fingerprint).isPresent();
	}


	@Override
	public List<MediaFileDTO> getAllFilesByWorkspaceId(String workspaceId) {
		return mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
				.eq(MediaFileEntity::getWorkspaceId, workspaceId))
			.stream()
			.map(this::entityConvertToDto)
			.collect(Collectors.toList());
	}


	@Override
	public long getCountByWorkspaceId(String workspaceId) {
		// 构建查询条件
		LambdaQueryWrapper<MediaFileEntity> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(MediaFileEntity::getWorkspaceId, workspaceId);

		// 执行查询并返回数量
		return mapper.selectCount(queryWrapper);
	}

	@Override
	public List<MediaFileEntity> listMediaFileEntity(String workspaceId, String jobId) {
		return mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getWorkspaceId, workspaceId).eq(MediaFileEntity::getJobId, jobId));
	}

	public List<MediaFileEntity> listByIsadd(String dkbh, String workspaceId) {
		return mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getWorkspaceId, workspaceId)
			.like(MediaFileEntity::getFileName, dkbh + "~"));
	}

	public ResponseResult updateExamByFileId(String fileId) {
		int examineStatus = getExamByFileId(fileId);
		if (examineStatus == 1) {
			LambdaUpdateWrapper<MediaFileEntity> updateWrapper = new LambdaUpdateWrapper<>();
			updateWrapper.eq(MediaFileEntity::getFileId, fileId)
				.set(MediaFileEntity::getExamine, 0);
			mapper.update(null, updateWrapper);
			return ResponseResult.success("审核未通过");
		} else if (examineStatus == 0) {
			LambdaUpdateWrapper<MediaFileEntity> updateWrapper = new LambdaUpdateWrapper<>();
			updateWrapper.eq(MediaFileEntity::getFileId, fileId)
				.set(MediaFileEntity::getExamine, 1);
			mapper.update(null, updateWrapper);
			return ResponseResult.success("审核通过");
		}
		return ResponseResult.error("媒体文件不存在");
	}

	public int getExamByFileId(String fileId) {
		MediaFileEntity entity = mapper.selectOne(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getFileId, fileId));
		return entity.getExamine();
	}

	public int approveByDkbh(String dkbh) {
		// 校验参数是否有效
		if (dkbh == null || dkbh.isEmpty()) {
			throw new IllegalArgumentException("dkbh 有误");
		}

		// 使用 MyBatis-Plus Lambda 表达式批量更新
		LambdaUpdateWrapper<MediaFileEntity> updateWrapper = new LambdaUpdateWrapper<>();
		updateWrapper.eq(MediaFileEntity::getDkbh, dkbh)
			.set(MediaFileEntity::getExamine, 1); // 将 examine 字段设置为 1


		// 返回审核通过的数量
		return mapper.update(null, updateWrapper);
	}


	@Override
	public int deleteMediaInfo(String workspaceId, String fileId) {
		int count = mapper.update(new LambdaUpdateWrapper<MediaFileEntity>().eq(MediaFileEntity::getFileId, fileId)
			.set(MediaFileEntity::getIsDelete, 1));
		return count;
	}


	@Override
	public List<String> getUniqueFilePaths(List<String> jobIds) {
		return mapper.selectList(
				new LambdaQueryWrapper<MediaFileEntity>()
					.in(MediaFileEntity::getJobId, jobIds))
			.stream()
			.map(MediaFileEntity::getFilePath)
			.distinct()
			.collect(Collectors.toList());
	}

	@Override
	public List<MediaFileDTO> getFilesByWorkspaceAndJobId(String workspaceId, String jobId) {
		return mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
				.eq(MediaFileEntity::getWorkspaceId, workspaceId)
				.eq(MediaFileEntity::getJobId, jobId))
			.stream()
			.map(this::entityConvertToDto).collect(Collectors.toList());
	}

	@Override
	public Boolean updateMediaFile(String workspaceId, MediaFileEntity mediaFileEntity) {


		boolean update1 = new LambdaUpdateChainWrapper<>(mapper).eq(MediaFileEntity::getFileId, mediaFileEntity.getFileId())
			.set(MediaFileEntity::getFileName, mediaFileEntity.getFileName())
			.set(MediaFileEntity::getCollectStatus, mediaFileEntity.getCollectStatus())
			.set(MediaFileEntity::getUserId, mediaFileEntity.getUserId())
			.update();
//        int update = mapper.update(mediaFileEntity, Wrappers.update(params));
		return update1;
	}


	/**
	 * Convert database entity objects into file data transfer object.
	 *
	 * @param entity
	 * @return
	 */
	private MediaFileDTO entityConvertToDto(MediaFileEntity entity) {
		MediaFileDTO.MediaFileDTOBuilder builder = MediaFileDTO.builder();

		if (entity != null) {
			builder.fileName(entity.getFileName())
				.fileId(entity.getFileId())
				.filePath(entity.getFilePath())
				.isOriginal(entity.getIsOriginal())
				.fingerprint(entity.getFingerprint())
				.objectKey(entity.getObjectKey())
				.tinnyFingerprint(entity.getTinnyFingerprint())
				.payload(entity.getPayload())
				.metadata(entity.getMetadata())
				.createTime(LocalDateTime.ofInstant(
					Instant.ofEpochMilli(entity.getCreateTime()), ZoneId.systemDefault()))
				.drone(entity.getDrone())
				.jobId(entity.getJobId());

		}

		return builder.build();
	}


	public void deleteLocalFile(String filePath) {
		try {
			File file = new File(filePath);
			if (file.exists()) {
				if (file.delete()) {
					log.info("文件已成功删除: " + filePath);
				} else {
					throw new RuntimeException("无法删除文件: " + filePath);
				}
			} else {
				log.info("文件不存在: " + filePath);
			}
		} catch (Exception e) {
			log.error("删除本地文件失败: " + e);
			throw new RuntimeException("删除本地文件失败: " + e);
		}
	}


	public List<MediaFileEntity> getMedia(String jobId) {
		return mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getJobId, jobId)
			.groupBy(MediaFileEntity::getFileName));  // 使用groupBy去重
	}


	/**
	 * 查询缩率图集合信息
	 *
	 * @param workspaceId
	 * @param jobId
	 * @return
	 */
	@Override
	public List<MediaFileEntity> findNailFilesList(String workspaceId, String jobId) {
		List<MediaFileEntity> mediaFileEntityList = mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
			.eq(MediaFileEntity::getWorkspaceId, workspaceId).eq(MediaFileEntity::getJobId, jobId));
		if (mediaFileEntityList.size() > 0) {
			for (MediaFileEntity mediaFileNailEntity : mediaFileEntityList) {
				mediaFileNailEntity.setMediaKey(mediaFileNailEntity.getObjectKey());
				mediaFileNailEntity.setObjectKey(mediaFileNailEntity.getObjectKey().replaceAll("(\\.[^.]*$)", "_small$1"));
			}
		}
		return mediaFileEntityList;
	}

	@Override
	public List<MediaFileEntity> getMediaByTime(long time) {
		List<MediaFileEntity> mediaFileEntityList = mapper.selectList(new LambdaQueryWrapper<MediaFileEntity>()
			.lt(MediaFileEntity::getCreateTime, time)
			.last("LIMIT 1000"));
		return mediaFileEntityList;
	}

	public List<MediaFileEntity> selectList(MediaFileEntity entity) {
		return mapper.selectList(Wrappers.lambdaQuery(entity));
	}

	@Override
	public List<String> getExistTinyFingerprints(String workspaceId, List<String> tinyFingerprints) {
		List<String> tinyFingerprintList = this.getAllTinyFingerprintsByWorkspaceId(workspaceId);
		return tinyFingerprints
			.stream()
			.filter(tinyFingerprintList::contains)
			.collect(Collectors.toList());

	}

	public List<String> getAllTinyFingerprintsByWorkspaceId(String workspaceId) {
		return getAllFilesByWorkspaceId(workspaceId)
			.stream()
			.map(MediaFileDTO::getTinnyFingerprint)
			.collect(Collectors.toList());
	}

	@Override
	public PaginationData<MediaJobDTO> mediaPage(String workspaceId, SearchMediaParam param) {
		param.setFileAddress(fileAddress + "/" + bucket);
		Page<MediaJobDTO> waylineJobDTOPage = mapper.mediaPage(new Page<MediaJobDTO>(param.getPage(), param.getPageSize()), workspaceId, param);
		return new PaginationData<MediaJobDTO>(waylineJobDTOPage.getRecords(), new Pagination(waylineJobDTOPage));
	}


	@Override
	public PaginationData<MediaJobDTO> mediaDetail(String jobId, Long page, Long pageSize) {
		Page<MediaJobDTO> waylineJobDTOPage = mapper.mediaDetail(new Page<MediaJobDTO>(page, pageSize), jobId, fileAddress + "/" + bucket);
		return new PaginationData<MediaJobDTO>(waylineJobDTOPage.getRecords(), new Pagination(waylineJobDTOPage));
	}

	@Override
	public MediaFileEntity getMediaFieByTid(String deviceId, String timestamp) {
		return mapper.getMediaFieByTid(deviceId, timestamp);
	}

	@Override
	public MediaFileCountVO getMediaFileCountByResultType(Integer resultType, String areaCode) {
		List<Long> deptIdList = SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId()));
		String permissionCondition = permissionBuilder.buildDataPermissionCondition(AuthUtil.getUserId(), "a");
		MediaFileCountVO mediaFileCountByResultType = mapper.getMediaFileCountByResultType(resultType, areaCode, deptIdList, permissionCondition);
		// 计算三维面积
		MediaFileCountVO mediaFileCountByResultType3D = mapper.calculateTheThreeDimensionalArea(resultType, areaCode, deptIdList, permissionCondition);
		if (mediaFileCountByResultType3D != null) {
			mediaFileCountByResultType.setGisNum(mediaFileCountByResultType3D.getGisNum());
		} else {
			mediaFileCountByResultType.setGisNum(0.0);
		}
		return mediaFileCountByResultType;
	}

	/**
	 * @param jobIds 任务ids
	 * @return
	 */
	@Override
	public List<MediaFileEntity> getJobsAllFiles(List<String> jobIds) {
		LambdaQueryWrapper<MediaFileEntity> query = Wrappers.<MediaFileEntity>lambdaQuery()
			.in(MediaFileEntity::getJobId, jobIds).orderByDesc(MediaFileEntity::getCreateTime);
		List<MediaFileEntity> attaches = mapper.selectList(query);
		return attaches;
	}

	@Override
	public List<MediaFileEntity> findNearByMediaUrl(EventHistoryDto dto) {
		return mapper.findNearByMediaUrl(dto);
	}
}