package com.pashanhoo.archive.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.DgArchivesConverter;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.*;
import com.pashanhoo.archive.mapper.DgArchivesMapper;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.mapper.DgBdcdyMapper;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessConverter;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogConverter;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogWithFileVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.DgFileSearchRequest;
import com.pashanhoo.file.service.DgFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 案卷基本信息 服务实现类
 * </p>
 *
 * @author
 * @since 2021-11-05
 */
@Service
public class DgArchivesServiceImpl extends ServiceImpl<DgArchivesMapper, DgArchivesDO> implements DgArchivesService {

    @Autowired
    private DgArchivesConverter dgarchivesConverter;

    @Autowired
    private DgArchivesMapper dgarchivesMapper;

    @Autowired
    private DgBdcdyService dgBdcdyService;

    @Autowired
    private DgBdcdyMapper dgBdcdyMapper;

    @Autowired
    private DgBdcdyConverter dgBdcdyConverter;

    @Autowired
    private DgBusinessService dgBusinessService;

    @Autowired
    private DgBusinessConverter dgBusinessConverter;

    @Autowired
    private DgArchivesCatalogService catalogService;

    @Autowired
    private DgArchivesCatalogConverter catalogConverter;

    @Autowired
    private DgFileService dgFileService;

    @Autowired
    private MinioUtil minioUtil;

    /**
     * 新增记录
     *
     * @param request
     * @return
     */
    @Override
    public boolean insertDgArchives(AddDgArchivesRequest request) {
        DgArchivesDO dgarchivesDO = dgarchivesConverter.addRequest2DO(request);
        return this.save(dgarchivesDO);
    }

    /**
     * 查询案卷基本信息
     *
     * @param bsmArchive
     * @return
     */
    @Override
    public ArchiveDetailAndCoverVO getDgArchivesDetailById(String bsmArchive) {
        ArchiveDetailAndCoverVO detailAndCoverVO = getCover(bsmArchive);
        //查询业务信息
        QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
        businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchive);
        DgBusinessDO businessDO = dgBusinessService.getOne(businessWrapper);
        DgBusinessDetailVO dgBusinessDetailVO = dgBusinessConverter.do2DetailVO(businessDO);
        detailAndCoverVO.setDgBusinessDetailVO(dgBusinessDetailVO);
        return detailAndCoverVO;
    }

    /**
     * 修改案卷基本信息,业务信息,不动产信息
     *
     * @param request
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateDgArchivesReplenish(UpdateArchiveAndOtherInfoRequest request) {

        //修改案卷基本信息
        UpdateDgArchivesRequest updateDgArchivesRequest = request.getUpdateDgArchivesRequest();
        DgArchivesDO dgArchivesDO = dgarchivesConverter.updateRequest2DO(updateDgArchivesRequest);
        String bsmArchives = dgArchivesDO.getBsmArchives();
        this.updateById(dgArchivesDO);

        //修改不动产信息,先删除.后插入
        List<UpdateDgBdcdyRequest> updateDgBdcdyRequests = request.getUpdateDgBdcdyRequests();
        List<DgBdcdyDO> dgBdcdyDOS = dgBdcdyConverter.voList2DoList(updateDgBdcdyRequests);
        //删除
        QueryWrapper<DgBdcdyDO> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
        dgBdcdyService.remove(wrapper);
        //插入
        dgBdcdyService.saveBatch(dgBdcdyDOS);

        //修改业务信息
        UpdateDgBusinessRequest updateDgBusinessRequest = request.getUpdateDgBusinessRequest();
        DgBusinessDO dgBusinessDO = dgBusinessConverter.updateRequest2DO(updateDgBusinessRequest);
        QueryWrapper<DgBusinessDO> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchives);
        return dgBusinessService.update(dgBusinessDO, queryWrapper);

    }

    /**
     * 根据条件进行列表查询
     *
     * @param request
     * @return
     */
    @Override
    public Page searchDgArchivesList(DgArchivesSearchRequest request) {
        Page<DgArchivesDO> pageParam = new Page<DgArchivesDO>(request.getCurrentPage(), request.getPageSize());
        QueryWrapper<DgArchivesDO> wrapper = new QueryWrapper<>();
        //设置默认排序
        wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());

        //增加条件
        // lt：less than 小于
        // le：less than or equal to 小于等于
        // eq：equal to 等于
        // ne：not equal to 不等于
        // ge：greater than or equal to 大于等于
        // gt：greater than 大于
        wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
        wrapper.eq(request.getAjbt() != null, "AJBT", request.getAjbt());
        wrapper.eq(request.getFlh() != null, "FLH", request.getFlh());
        wrapper.eq(request.getMlh() != null, "MLH", request.getMlh());
        wrapper.eq(request.getAjh() != null, "AJH", request.getAjh());
        wrapper.eq(request.getNd() != null, "ND", request.getNd());
        wrapper.eq(request.getDazt() != null, "DAZT", request.getDazt());
        wrapper.eq(request.getMj() != null, "MJ", request.getMj());
        wrapper.ge(request.getQsrq() != null, "QSRQ", request.getQsrq());
        wrapper.le(request.getZzrq() != null, "ZZRQ", request.getZzrq());
        wrapper.eq(request.getHh() != null, "HH", request.getHh());
        wrapper.eq(request.getCfwz() != null, "CFWZ", request.getCfwz());
        wrapper.eq(request.getZtc() != null, "ZTC", request.getZtc());
        Page page = this.page(pageParam, wrapper);
        //将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
        return page.setRecords(dgarchivesConverter.doList2ListVOList(page.getRecords()));
    }

    /**
     * 根据档案标识码加载左侧菜单
     *
     * @param bsmArchives 档案标识码
     * @return
     */
    @Override
    public List getArchiveLiftMenu(String bsmArchives) {
        DgArchivesDO archivesDO = this.getById(bsmArchives);
        Integer status = archivesDO.getDazt().intValue();

        /*状态判断.如果状态为:1,2,3显示为不动产单元号
          如果状态为:4,5,6,7,8显示为档案号
         */
        List<DgBdcdyDO> dgBdcdyDOS = null;
        if (status.equals(1) || status.equals(2) || status.equals(3)) {
            QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
            bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
            dgBdcdyDOS = dgBdcdyMapper.selectList(bdcdyWrapper);
            return dgBdcdyDOS;
        }
        return dgBdcdyDOS;
    }

    /**
     * 档案查找
     *
     * @param request
     * @return
     */
    @Override
    public IPage<SearchArchiveVO> searchArchive(SearchArchiveRequest request) {

        IPage<SearchArchiveVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
        return dgarchivesMapper.searchArchive(pageParam, request);
    }

    /**
     * 档案封皮查找
     *
     * @param bsmArchive
     * @return
     */
    @Override
    public ArchiveDetailAndCoverVO searchArchivesCover(String bsmArchive) {

        return getCover(bsmArchive);
    }

    /**
     * 1.比对新增的记录数据库是否存在，如果不存在则新增
     * 2.比对数据库的数据是否存在前端传递的集合中，不存在则删除，并且删除对应的电子附件数据
     * 3.如果目录记录标识码与数据库一致，直接更新当前的记录
     *
     * @param requests
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateCatalog(List<UpdateDgArchivesCatalogRequest> requests) {

        List<UpdateDgArchivesCatalogRequest> updateCatalogs = requests.stream().filter(item -> !StrUtil.isNullOrUndefined(item.getBsmCatalog())).collect(Collectors.toList());
        List<UpdateDgArchivesCatalogRequest> addCatalogs = requests.stream().filter(item -> StrUtil.isNullOrUndefined(item.getBsmCatalog())).collect(Collectors.toList());

        boolean flag = false;

        //存量数据更新.
        if (updateCatalogs.size() != 0) {
            String bsmArchive = updateCatalogs.stream().map(UpdateDgArchivesCatalogRequest::getBsmArchives).findFirst().orElse(null);
            QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
            catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
            List<DgArchivesCatalogDO> catalogsAlreadyExist = catalogService.list(catalogWrapper);
            //入参的存量数据小于数据库内数据,删除数据库内多余数据
            if (updateCatalogs.size() < catalogsAlreadyExist.size()) {
                List<String> updateBsmCatalogs = updateCatalogs.stream().map(UpdateDgArchivesCatalogRequest::getBsmCatalog).collect(Collectors.toList());
                List<String> alreadyExistBsmCatalogs = catalogsAlreadyExist.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
                //过滤数据
                List<String> deleteBsmCatalogs = alreadyExistBsmCatalogs.stream().filter(item -> !updateBsmCatalogs.contains(item)).collect(Collectors.toList());
                //删除附件表数据
                QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
                fileWrapper.lambda().in(DgFileDO::getBsmCatalog, deleteBsmCatalogs);
                dgFileService.remove(fileWrapper);
                //删除目录表多余数据
                catalogWrapper.lambda().in(DgArchivesCatalogDO::getBsmCatalog,deleteBsmCatalogs);
                catalogService.remove(catalogWrapper);
            }
            List<DgArchivesCatalogDO> updateCatalogDOs = catalogConverter.updateList2DO(updateCatalogs);
            flag = catalogService.updateBatchById(updateCatalogDOs);
        }

        if (addCatalogs.size() != 0) {
            //新增数据
            List<DgArchivesCatalogDO> addCatalogDOs = catalogConverter.updateList2DO(addCatalogs);
            flag = catalogService.saveBatch(addCatalogDOs);
        }
        return flag;

    }

    /**
     * 查找档案目录和对应的附件列表
     * @param request
     * @return
     */
    @Override
    public List<DgArchivesCatalogWithFileVO> searchDgFileList(DgFileSearchRequest request) {

        List<DgArchivesCatalogWithFileVO> fileListVOS = dgarchivesMapper.selectCatalogWithFile(request);

        for (DgArchivesCatalogWithFileVO fileListVO : fileListVOS) {
            for (DgFileDO dgFileDO : fileListVO.getDgFileDOS()) {
                if (dgFileDO.getFjurl() != null) {
                    String previewUrl = minioUtil.getPreviewUrl(dgFileDO.getFjurl());
                    dgFileDO.setFjurl(previewUrl);
                }
            }
        }
        return fileListVOS;
    }

    /**
     * 档案目录查找
     *
     * @param bsmArchive
     * @return
     */
    @Override
    public List<DgArchivesCatalogListVO> searchCatalog(String bsmArchive) {
        QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
        catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive).orderByAsc(DgArchivesCatalogDO::getXh);
        List<DgArchivesCatalogDO> list = catalogService.list(catalogWrapper);
        return catalogConverter.doList2ListVOList(list);
    }

    private ArchiveDetailAndCoverVO getCover(String bsmArchive) {
        DgArchivesDO archivesDO = this.getById(bsmArchive);
        DgArchivesDetailVO dgArchivesDetailVO = dgarchivesConverter.do2DetailVO(archivesDO);

        QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
        bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchive);
        List<DgBdcdyDO> bdcdyDOS = dgBdcdyService.list(bdcdyWrapper);
        List<DgBdcdyDetailVO> bdcdyDetailVOList = dgBdcdyConverter.do2DetailVOList(bdcdyDOS);

        ArchiveDetailAndCoverVO archiveDetailAndCoverVO = new ArchiveDetailAndCoverVO();
        archiveDetailAndCoverVO.setDgArchivesDetailVO(dgArchivesDetailVO);
        archiveDetailAndCoverVO.setDgBdcdyDetailVOList(bdcdyDetailVOList);
        return archiveDetailAndCoverVO;
    }
}