package jnpf.dmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jnpf.dmsEntity.DmsDanganCundangShenqingEntity;
import jnpf.dmsEntity.DmsDanganCundangShenqingDanganheEntity;
import jnpf.dmsEntity.form.DmsDanganCundangJieshouDanganheForm;
import jnpf.dmsEntity.form.DmsDanganCundangJieshouForm;
import jnpf.dmsMapper.DmsDanganCundangShenqingDanganheMapper;
import jnpf.dmsMapper.DmsDanganCundangShenqingMapper;
import jnpf.dmsService.DmsDanganCundangJieshouService;
import jnpf.exception.DataException;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

@Service
@RequiredArgsConstructor
public class DmsDanganCundangJieshouServiceImpl implements DmsDanganCundangJieshouService {

    private final DmsDanganCundangShenqingDanganheMapper danganheMapper;
    private final DmsDanganCundangShenqingMapper shenqingMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void jieshou(DmsDanganCundangJieshouForm form) throws DataException {
        if (form == null) {
            throw new DataException("档案存档接收参数不能为空");
        }
        Set<String> danganheIds = resolveDanganheIds(form.getDanganheXinxi());
        String jieshouRen = requireValue(form.getBizUserId(), "接收人(biz_user_id)");
        String yijiaoRen = requireValue(form.getBizReviewUser(), "移交人(biz_review_user)");
        String bizSign = requireValue(form.getBizSign(), "接收签名(biz_sign)");
        String bizReviewSign = requireValue(form.getBizReviewSign(), "移交签名(biz_review_sign)");

        LambdaQueryWrapper<DmsDanganCundangShenqingDanganheEntity> existingQuery = new LambdaQueryWrapper<>();
        existingQuery.in(DmsDanganCundangShenqingDanganheEntity::getId, danganheIds)
                .isNull(DmsDanganCundangShenqingDanganheEntity::getDeleteMark);
        List<DmsDanganCundangShenqingDanganheEntity> danganheList = danganheMapper.selectList(existingQuery);
        if (danganheList.size() != danganheIds.size()) {
            throw new DataException("存在未找到或已删除的档案盒记录，无法接收");
        }
        for (DmsDanganCundangShenqingDanganheEntity danganhe : danganheList) {
            if (!trimToEmpty(danganhe.getJieshouRen()).isEmpty()) {
                throw new DataException("档案盒已接收，不能重复接收");
            }
        }

        Date receivedAt = new Date();
        LambdaUpdateWrapper<DmsDanganCundangShenqingDanganheEntity> update = new LambdaUpdateWrapper<>();
        update.in(DmsDanganCundangShenqingDanganheEntity::getId, danganheIds)
                .isNull(DmsDanganCundangShenqingDanganheEntity::getDeleteMark)
                .and(wrapper -> wrapper.isNull(DmsDanganCundangShenqingDanganheEntity::getJieshouRen)
                        .or()
                        .eq(DmsDanganCundangShenqingDanganheEntity::getJieshouRen, ""))
                .set(DmsDanganCundangShenqingDanganheEntity::getJieshouRen, jieshouRen)
                .set(DmsDanganCundangShenqingDanganheEntity::getYijiaoRen, yijiaoRen)
                .set(DmsDanganCundangShenqingDanganheEntity::getBizSign, bizSign)
                .set(DmsDanganCundangShenqingDanganheEntity::getBizReviewSign, bizReviewSign)
                .set(DmsDanganCundangShenqingDanganheEntity::getJieshouRiqi, receivedAt);
        if (danganheMapper.update(null, update) != danganheIds.size()) {
            throw new DataException("档案盒已接收，不能重复接收");
        }
    }

    @Override
    @Transactional(readOnly = true)
    public DmsDanganCundangShenqingDanganheEntity check(String danganheBianhao) throws DataException {
        String queryValue = requireValue(danganheBianhao, "档案盒编号(danganhe_bianhao)");
        LambdaQueryWrapper<DmsDanganCundangShenqingDanganheEntity> danganheQuery = new LambdaQueryWrapper<>();
        danganheQuery.and(wrapper -> wrapper
                        .eq(DmsDanganCundangShenqingDanganheEntity::getDanganheBianhao, queryValue)
                        .or()
                        .eq(DmsDanganCundangShenqingDanganheEntity::getId, queryValue))
                .isNull(DmsDanganCundangShenqingDanganheEntity::getDeleteMark);
        List<DmsDanganCundangShenqingDanganheEntity> danganheList = danganheMapper.selectList(danganheQuery);
        if (danganheList.isEmpty()) {
            throw new DataException("未找到对应的档案盒记录");
        }
        if (danganheList.size() > 1) {
            throw new DataException("档案盒编号对应多条记录，请使用档案盒ID校验");
        }

        DmsDanganCundangShenqingDanganheEntity danganhe = danganheList.get(0);
        String shenqingId = trimToEmpty(danganhe.getForeignId());
        if (shenqingId.isEmpty()) {
            throw new DataException("档案盒未关联存档申请，无法接收");
        }
        LambdaQueryWrapper<DmsDanganCundangShenqingEntity> shenqingQuery = new LambdaQueryWrapper<>();
        shenqingQuery.eq(DmsDanganCundangShenqingEntity::getId, shenqingId)
                .isNull(DmsDanganCundangShenqingEntity::getDeleteMark);
        DmsDanganCundangShenqingEntity shenqing = shenqingMapper.selectOne(shenqingQuery);
        if (shenqing == null) {
            throw new DataException("未找到档案盒关联的存档申请");
        }
        if (!Integer.valueOf(2).equals(shenqing.getFlowState())) {
            throw new DataException("档案存档申请尚未审批通过，无法接收");
        }
        if (!trimToEmpty(danganhe.getJieshouRen()).isEmpty()) {
            throw new DataException("档案盒已接收，不能重复接收");
        }
        return danganhe;
    }

    private Set<String> resolveDanganheIds(List<DmsDanganCundangJieshouDanganheForm> danganheXinxi)
            throws DataException {
        if (danganheXinxi == null || danganheXinxi.isEmpty()) {
            throw new DataException("档案盒信息(danganhe_xinxi)不能为空");
        }
        Set<String> ids = new LinkedHashSet<>();
        for (DmsDanganCundangJieshouDanganheForm danganhe : danganheXinxi) {
            if (danganhe == null) {
                throw new DataException("档案盒信息中不能包含空记录");
            }
            String id = trimToEmpty(danganhe.getId());
            String fId = trimToEmpty(danganhe.getFId());
            if (id.isEmpty() && fId.isEmpty()) {
                throw new DataException("档案盒记录的id或f_id不能为空");
            }
            if (!id.isEmpty() && !fId.isEmpty() && !id.equals(fId)) {
                throw new DataException("档案盒记录的id与f_id不一致");
            }
            ids.add(id.isEmpty() ? fId : id);
        }
        if (ids.size() != danganheXinxi.size()) {
            throw new DataException("档案盒信息中不能包含重复记录");
        }
        return ids;
    }

    private String requireValue(String value, String fieldName) throws DataException {
        String resolved = trimToEmpty(value);
        if (resolved.isEmpty()) {
            throw new DataException(fieldName + "不能为空");
        }
        return resolved;
    }

    private String trimToEmpty(String value) {
        return value == null ? "" : value.trim();
    }
}