package com.pashanhoo.modify.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONUtil;
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.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.ArchiveStatus;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.service.DgFileService;
import com.pashanhoo.modify.entity.DgArchivesModifyConverter;
import com.pashanhoo.modify.entity.DgModifyDO;
import com.pashanhoo.modify.entity.vo.*;
import com.pashanhoo.modify.mapper.DgArchivesModifyMapper;
import com.pashanhoo.modify.service.DgArchivesModifyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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 DgArchivesModifyServiceImpl extends ServiceImpl<DgArchivesModifyMapper, DgModifyDO> implements DgArchivesModifyService {

    @Autowired
    private DgArchivesModifyConverter dgarchivesmodifyConverter;

    @Autowired
    private DgArchivesModifyMapper dgarchivesmodifyMapper;

    @Autowired
    DgArchivesService archivesService;

    @Autowired
    DgBusinessService businessService;

    @Autowired
    DgBdcdyService bdcdyService;

    @Autowired
    DgArchivesCatalogService catalogService;

    @Autowired
    DgFileService fileService;

    /**
     * 新增记录
     * 1.档案修改记录并把原有的档案信息存入clob字段
     * 2.修改案卷基本信息状态为正在修改
     *
     * @param bsmArchive
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertDgArchivesModify(String bsmArchive) {
        //获取案卷基本信息
        DgArchivesDO archive = archivesService.getById(bsmArchive);
        //获取业务信息
        QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
        businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchive);
        DgBusinessDO business = businessService.getOne(businessWrapper);
        //获取不动产信息
        QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
        bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchive);
        List<DgBdcdyDO> bdcdyList = bdcdyService.list(bdcdyWrapper);
        //获取卷内目录
        QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
        catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
        List<DgArchivesCatalogDO> catalogList = catalogService.list(catalogWrapper);
        //获取案卷附件
        List<String> catalogIdList = catalogList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
        QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
        fileWrapper.lambda().in(DgFileDO::getBsmCatalog, catalogIdList);
        List<DgFileDO> fileList = fileService.list(fileWrapper);

        ModifyRecord modifyRecord = new ModifyRecord();
        modifyRecord.setArchivesDO(archive);
        modifyRecord.setDgBusinessDO(business);
        modifyRecord.setDgBdcdyDOList(bdcdyList);
        modifyRecord.setCatalogDOList(catalogList);
        modifyRecord.setDgFileDOList(fileList);

        JSONConfig jsonConfig = JSONConfig.create().setIgnoreNullValue(false).setOrder(true).setDateFormat("yyyy-MM-dd HH:mm:ss");
        JSON modifyRecordJson = JSONUtil.parse(modifyRecord, jsonConfig);
        String modifyRecordStr = JSONUtil.toJsonStr(modifyRecordJson);

        DgModifyDO modifyDO = new DgModifyDO();
        modifyDO.setBsmArchives(bsmArchive);
        modifyDO.setXgbh(IdWorker.get32UUID());
        modifyDO.setYdaxx(modifyRecordStr);
        // TODO: 2021/11/23/0023 暂时填null
        modifyDO.setXgnr(null);
        modifyDO.setCreateTime(DateTime.now());
        // TODO: 2021/11/23/0023 暂时填null
        modifyDO.setCreater(null);
        modifyDO.setState("1");
        modifyDO.setGdsj(null);

        //修改档案状态
        UpdateWrapper<DgArchivesDO> archiveUpdateWrapper = new UpdateWrapper<>();
        archiveUpdateWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.MODIFYING.getCode()).eq(DgArchivesDO::getBsmArchives,bsmArchive);
        archivesService.update(archiveUpdateWrapper);

        return this.save(modifyDO);
    }

    /**
     * 根据主键查询记录详情
     *
     * @param id
     * @return
     */
    @Override
    public DgArchivesModifyDetailVO getDgArchivesModifyDetailById(String id) {
        DgModifyDO dgarchivesmodifyDO = this.getById(id);
        return dgarchivesmodifyConverter.do2DetailVO(dgarchivesmodifyDO);
    }

    /**
     * 修改记录状态为已归档和归档日期，一并修改档案记录的状态为在库
     *
     * @param request
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateDgArchivesModify(UpdateDgArchivesModifyRequest request) {
        DgModifyDO dgarchivesmodifyDO = dgarchivesmodifyConverter.updateRequest2DO(request);
        UpdateWrapper<DgModifyDO> modifyWrapper = new UpdateWrapper<>();
        modifyWrapper.lambda().set(DgModifyDO::getState, "2").set(DgModifyDO::getGdsj, DateTime.now());
        this.update(dgarchivesmodifyDO, modifyWrapper);
        //修改档案记录状态
        UpdateWrapper<DgArchivesDO> archivesWrapper = new UpdateWrapper<>();
        archivesWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.STORED.getCode()).eq(DgArchivesDO::getBsmArchives, request.getBsmArchives());
        return archivesService.update(archivesWrapper);
    }

    /**
     * 根据条件进行列表查询
     *
     * @param request
     * @return
     */
    @Override
    public IPage<DgArchivesModifyListVO> searchDgArchivesModifyList(DgArchivesModifySearchRequest request) {
        IPage<DgArchivesModifyListVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
        IPage<DgArchivesModifyListVO> list = dgarchivesmodifyMapper.searchDgArchivesModifyList(pageParam, request);
        return list;
    }

    /**
     * 一个档案对应的修改列表查询
     *
     * @param bsmArchive
     * @return
     */
    @Override
    public List<DgArchivesModifyDetailVO> getArchiveWithModify(String bsmArchive) {
        QueryWrapper<DgModifyDO> modifyWrapper = new QueryWrapper<>();
        modifyWrapper.lambda().eq(DgModifyDO::getBsmArchives, bsmArchive);
        List<DgModifyDO> modifyDOS = this.list(modifyWrapper);
        return dgarchivesmodifyConverter.doList2DetailVOList(modifyDOS);
    }

    /**
     * 删除修改记录，并回滚档案信息和修改档案状态在库
     * @param bsmModify
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delete(String bsmModify) {
        //获取修改前信息
        DgModifyDO modifyDO = this.getById(bsmModify);
        String bsmArchives = modifyDO.getBsmArchives();
        //获取原档案信息json字段
        String ydaxxJson = modifyDO.getYdaxx();
        ModifyRecord modifyRecord = JSONUtil.toBean(ydaxxJson, ModifyRecord.class);

        //删除修改记录表数据
        this.removeById(bsmModify);

        //删除案卷附件
        QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
        catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchives);
        List<DgArchivesCatalogDO> catalogDOList = catalogService.list(catalogWrapper);
        List<String> bsmCatalogList = catalogDOList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
        QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
        fileWrapper.lambda().in(DgFileDO::getBsmCatalog, bsmCatalogList);
        fileService.remove(fileWrapper);
        //插入原案卷附件
        fileService.saveBatch(modifyRecord.getDgFileDOList());

        //删除案卷目录
        catalogService.removeByIds(bsmCatalogList);
        //插入原案卷目录
        catalogService.saveBatch(modifyRecord.getCatalogDOList());

        //删除不动产信息
        QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
        bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
        bdcdyService.remove(bdcdyWrapper);
        //插入原不动产信息
        bdcdyService.saveBatch(modifyRecord.getDgBdcdyDOList());

        //删除业务信息
        QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
        businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchives);
        businessService.remove(businessWrapper);
        //插入原业务信息
        businessService.save(modifyRecord.getDgBusinessDO());

        //更新档案信息
        DgArchivesDO archivesDO = modifyRecord.getArchivesDO();
        archivesDO.setDazt(ArchiveStatus.STORED.getCode());
        return archivesService.updateById(archivesDO);
    }
}