package com.pashanhoo.replenish.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.ArchiveStatus;
import com.pashanhoo.archive.entity.DgArchivesConverter;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.AddDgArchivesRequest;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessConverter;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.util.SysCode.SysCodeUtil;
import com.pashanhoo.common.util.SysCode.SysCodeVO;
import com.pashanhoo.common.util.fileupload.MinioConfig;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.service.DgFileService;
import com.pashanhoo.replenish.entity.DgArchivesReplenishConverter;
import com.pashanhoo.replenish.entity.DgArchivesReplenishDO;
import com.pashanhoo.replenish.entity.vo.AddDgArchivesReplenishRequest;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishDetailVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishSearchRequest;
import com.pashanhoo.replenish.mapper.DgArchivesReplenishMapper;
import com.pashanhoo.replenish.service.DgArchivesReplenishService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * <p>
 * 档案补录信息 服务实现类
 * </p>
 *
 * @author
 * @since 2021-11-05
 */
@Service
public class DgArchivesReplenishServiceImpl extends ServiceImpl<DgArchivesReplenishMapper, DgArchivesReplenishDO> implements DgArchivesReplenishService {

    @Autowired
    private DgArchivesReplenishConverter dgarchivesreplenishConverter;

    @Autowired
    private DgArchivesReplenishMapper dgarchivesreplenishMapper;

    @Autowired
    private DgArchivesService dgArchivesService;

    @Autowired
    private DgArchivesConverter dgArchivesConverter;

    @Autowired
    private DgBusinessService dgBusinessService;

    @Autowired
    private DgBusinessConverter dgBusinessConverter;

    @Autowired
    private DgBdcdyService dgBdcdyService;

    @Autowired
    private DgBdcdyConverter dgBdcdyConverter;

    @Autowired
    SysCodeUtil sysCodeUtil;

    @Autowired
    DgArchivesCatalogService dgArchivesCatalogService;

    @Autowired
    DgFileService dgFileService;

    @Autowired
    MinioUtil minioUtil;

    @Autowired
    MinioConfig minioConfig;


    /**
     * 新增记录
     *
     * @param request
     * @param bsmArchive 生成主键
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertDgArchivesReplenish(AddDgArchivesReplenishRequest request,String bsmArchive) {

        //案卷基本信息
        AddDgArchivesRequest addDgArchivesRequest = request.getAddDgArchivesRequest();
        addDgArchivesRequest.setBsmArchives(bsmArchive);
        addDgArchivesRequest.setDazt(ArchiveStatus.REPLENISHING.getCode());
        DgArchivesDO dgArchivesDO = dgArchivesConverter.addRequest2DO(addDgArchivesRequest);
        dgArchivesService.save(dgArchivesDO);

        //业务信息
        AddDgBusinessRequest addDgBusinessRequest = request.getAddDgBusinessRequest();
        addDgBusinessRequest.setBsmArchives(bsmArchive);
        DgBusinessDO dgBusinessDO = dgBusinessConverter.addRequest2DO(addDgBusinessRequest);
        dgBusinessService.save(dgBusinessDO);

        //不动产单元信息
        List<AddDgBdcdyRequest> addDgBdcdyRequests = request.getAddDgBdcdyRequests();
        for (AddDgBdcdyRequest addDgBdcdyRequest : addDgBdcdyRequests) {
            addDgBdcdyRequest.setBsmArchives(bsmArchive);
        }
        List<DgBdcdyDO> dgBdcdyDOS = dgBdcdyConverter.addRequestListDO(addDgBdcdyRequests);
        dgBdcdyService.saveBatch(dgBdcdyDOS);

        //档案补录记录
        DgArchivesReplenishDO dgArchivesReplenishDO = new DgArchivesReplenishDO();
        dgArchivesReplenishDO.setBsmArchives(bsmArchive);
        //获取补录编号
        SysCodeVO sysCodeVO = new SysCodeVO();
        sysCodeVO.setTaskno("BL" + DateUtil.year(DateUtil.date()));
        sysCodeVO.setCtype("sequence");
        sysCodeVO.setTaskname("补录序列号");
        sysCodeVO.setTaskchild(5);
        String blbh = sysCodeUtil.getSequence(sysCodeVO);
        dgArchivesReplenishDO.setBlbh(blbh);
        /******************************************************/
        dgArchivesReplenishDO.setCreateTime(DateTime.now());
        dgArchivesReplenishDO.setCreater(null);
        dgArchivesReplenishDO.setBz(null);
        dgArchivesReplenishDO.setState("1");
        dgArchivesReplenishDO.setGdsj(null);
        return this.save(dgArchivesReplenishDO);
    }

    /**
     * 根据主键查询记录详情
     *
     * @param id
     * @return
     */
    @Override
    public DgArchivesReplenishDetailVO getDgArchivesReplenishDetailById(String id) {
        DgArchivesReplenishDO dgarchivesreplenishDO = this.getById(id);
        return dgarchivesreplenishConverter.do2DetailVO(dgarchivesreplenishDO);
    }

    /**
     * 补录列表根据条件查询
     *
     * @param request
     * @return
     */
    @Override
    public IPage<DgArchivesReplenishListVO> searchDgArchivesReplenishList(DgArchivesReplenishSearchRequest request) {

        IPage<DgArchivesReplenishListVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
        IPage<DgArchivesReplenishListVO> result = dgarchivesreplenishMapper.search(pageParam, request);
        List<DgArchivesReplenishListVO> records = result.getRecords();
        List<DgArchivesReplenishListVO> clean = records.stream().filter(distinctByKey(DgArchivesReplenishListVO::getBsmArchives)).collect(Collectors.toList());
        result.setTotal(clean.size());
        return result.setRecords(clean);
    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        ConcurrentHashMap<Object, Boolean> hashMap = new ConcurrentHashMap<>();
        return t -> hashMap.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    /**
     * 删除补录信息和对应档案资料
     *
     * @param bsmArchives 档案标识码
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delete(List<String> bsmArchives) throws Exception {
        //删除补录记录
        QueryWrapper<DgArchivesReplenishDO> replenishWrapper = new QueryWrapper<>();
        replenishWrapper.lambda().in(DgArchivesReplenishDO::getBsmArchives, bsmArchives);
        this.remove(replenishWrapper);

        //删除不动产信息
        QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
        bdcdyWrapper.lambda().in(DgBdcdyDO::getBsmArchives, bsmArchives);
        dgBdcdyService.remove(bdcdyWrapper);

        //删除档案业务信息
        QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
        businessWrapper.lambda().in(DgBusinessDO::getBsmArchives, bsmArchives);
        dgBusinessService.remove(businessWrapper);

        //删除卷内目录信息
        QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
        catalogWrapper.lambda().in(DgArchivesCatalogDO::getBsmArchives, bsmArchives);
        List<DgArchivesCatalogDO> catalogList = dgArchivesCatalogService.list(catalogWrapper);
        // TODO: 2021/11/16/0016 删除卷内目录操作移动到删除附件表之后

        //删除附件表信息
        List<String> bsmCatalogs = new ArrayList<>();
        for (DgArchivesCatalogDO dgArchivesCatalogDO : catalogList) {
            bsmCatalogs.add(dgArchivesCatalogDO.getBsmCatalog());
        }
        QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
        fileWrapper.lambda().select(DgFileDO::getFjurl).in(DgFileDO::getBsmCatalog, bsmCatalogs);
        //获取文件存储路径
        List<DgFileDO> files = dgFileService.list(fileWrapper);
        QueryWrapper<DgFileDO> deleteWrapper = new QueryWrapper<>();
        deleteWrapper.lambda().in(DgFileDO::getBsmCatalog, bsmCatalogs);
        dgFileService.remove(deleteWrapper);
        //删除卷内目录.测试环境主外键约束需要先删除附件表再删除卷内目录表.所以代码移动到这里
        dgArchivesCatalogService.remove(catalogWrapper);

        //删除档案信息表
        QueryWrapper<DgArchivesDO> archivesWrapper = new QueryWrapper<>();
        archivesWrapper.lambda().in(DgArchivesDO::getBsmArchives, bsmArchives);
        boolean flag = dgArchivesService.remove(archivesWrapper);

        //删除文件服务器附件
        List<String> fileUrls = files.stream().map(DgFileDO::getFjurl).collect(Collectors.toList());
        for (String fileUrl : fileUrls) {
            minioUtil.removeObject(minioConfig.getBucket(), fileUrl);
        }

        return flag;
    }

    /**
     * 补录归档
     * 补录记录的状态为已归档和归档日期，一并修改档案记录的状态为在库,判断卷内目录和每个卷内目录对应的附件列表是否为空,如果为空不能归档.
     *
     * @param bsmModify  补录标识码
     * @param bsmArchive 档案标识码
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean doReplenishArchive(String bsmModify, String bsmArchive) {

        //判断卷内目录和附件是否有数据
        QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
        QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
        catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
        //目录集合
        List<DgArchivesCatalogDO> catalogDOList = dgArchivesCatalogService.list(catalogWrapper);
        //获取附件集合
        List<String> bsmCatalogs = catalogDOList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());

        if (CollUtil.isEmpty(catalogDOList)) {
            return false;
        }
        for (String bsmCatalog : bsmCatalogs) {
            fileWrapper.lambda().eq(DgFileDO::getBsmCatalog, bsmCatalog);
            List<DgFileDO> fileDOList = dgFileService.list(fileWrapper);
            if (CollUtil.isEmpty(fileDOList)) {
                return false;
            }
        }

        //更新补录表归档信息
        UpdateWrapper<DgArchivesReplenishDO> replenishUpdateWrapper = new UpdateWrapper<>();
        DgArchivesReplenishDO replenishDO = new DgArchivesReplenishDO();
        replenishDO.setBsmModify(bsmModify);
        replenishUpdateWrapper.lambda().set(DgArchivesReplenishDO::getCreateTime, DateUtil.date()).set(DgArchivesReplenishDO::getState, "2").eq(DgArchivesReplenishDO::getBsmModify, bsmModify);
        this.update(replenishDO, replenishUpdateWrapper);

        //更新档案表状态
        UpdateWrapper<DgArchivesDO> archiveUpdateWrapper = new UpdateWrapper<>();
        DgArchivesDO archivesDO = new DgArchivesDO();
        archivesDO.setBsmArchives(bsmArchive);
        archiveUpdateWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.STORED.getCode()).eq(DgArchivesDO::getBsmArchives, bsmArchive);
        return dgArchivesService.update(archivesDO, archiveUpdateWrapper);
    }

}