package jnpf.dmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jnpf.audit.sdk.annotation.AuditLog;
import jnpf.base.UserInfo;
import jnpf.dmsEntity.DmsDanganCundangShenqingDanganheEntity;
import jnpf.dmsEntity.DmsDanganJieyueFuyinShenqingZixiangEntity;
import jnpf.dmsEntity.form.DmsDanganJieyueFuyinGuihuanForm;
import jnpf.dmsEntity.vo.DmsDanganJieyueFuyinGuihuanCheckVO;
import jnpf.dmsMapper.DmsDanganCundangShenqingDanganheMapper;
import jnpf.dmsMapper.DmsDanganJieyueFuyinShenqingZixiangMapper;
import jnpf.dmsPermission.DmsCurrentIdentity;
import jnpf.dmsService.DmsDanganJieyueFuyinGuihuanService;
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 DmsDanganJieyueFuyinGuihuanServiceImpl implements DmsDanganJieyueFuyinGuihuanService {

    private final DmsDanganJieyueFuyinShenqingZixiangMapper zixiangMapper;
    private final DmsDanganCundangShenqingDanganheMapper danganheMapper;
    private final DmsCurrentIdentity currentIdentity;

    @Override
    @Transactional(rollbackFor = Exception.class)
    @AuditLog(
            action = "LOAN_COPY_RETURN",
            label = "档案借阅复印归还",
            bizModule = "档案借阅/复印归还",
            bizType = "DMS_LOAN_COPY",
            bizCodeExpr = "",
            bizCodeRequired = false,
            targetTable = "dms_dangan_jieyue_fuyin_shenqing_zixiang",
            targetIdExpr = "#p0[0].fId",
            targetIdsExpr = "#p0.![fId]",
            diff = true,
            entityClass = DmsDanganJieyueFuyinShenqingZixiangEntity.class
    )
    public void guihuan(List<DmsDanganJieyueFuyinGuihuanForm> forms) throws DataException {
        Set<String> detailIds = resolveIds(forms);
        List<DmsDanganJieyueFuyinShenqingZixiangEntity> details = findDetails(detailIds);
        ensureNotReturned(details);
        Set<String> danganheIds = resolveDanganheIds(details);
        UserInfo user = currentIdentity.requireUser();
        String userId = requireValue(user.getUserId(), "当前用户");
        String organizeId = trimToNull(user.getOrganizeId());

        LambdaUpdateWrapper<DmsDanganCundangShenqingDanganheEntity> clearLoan = new LambdaUpdateWrapper<>();
        clearLoan.in(DmsDanganCundangShenqingDanganheEntity::getId, danganheIds)
                .isNull(DmsDanganCundangShenqingDanganheEntity::getDeleteMark)
                .set(DmsDanganCundangShenqingDanganheEntity::getJieyueId, null);
        if (danganheMapper.update(null, clearLoan) != danganheIds.size()) {
            throw new DataException("存在未找到或已删除的档案盒，无法归还档案借阅复印记录");
        }

        LambdaUpdateWrapper<DmsDanganJieyueFuyinShenqingZixiangEntity> update = new LambdaUpdateWrapper<>();
        update.in(DmsDanganJieyueFuyinShenqingZixiangEntity::getId, detailIds)
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getDeleteMark)
                .and(wrapper -> wrapper.isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanRen)
                        .or()
                        .eq(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanRen, ""))
                .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanRen, userId)
                .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanRiqi, new Date())
                .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanBumen, organizeId);
        if (zixiangMapper.update(null, update) != detailIds.size()) {
            throw new DataException("档案借阅复印子项已归还，不能重复归还");
        }
    }

    @Override
    @Transactional(readOnly = true)
    public DmsDanganJieyueFuyinGuihuanCheckVO check(String danganheBianhao) throws DataException {
        String value = requireValue(danganheBianhao, "档案盒编号(danganhe_bianhao)");
        LambdaQueryWrapper<DmsDanganJieyueFuyinShenqingZixiangEntity> query = new LambdaQueryWrapper<>();
        query.and(wrapper -> wrapper.eq(DmsDanganJieyueFuyinShenqingZixiangEntity::getDanganheId, value)
                        .or()
                        .eq(DmsDanganJieyueFuyinShenqingZixiangEntity::getDanganheBianhao, value))
                .eq(DmsDanganJieyueFuyinShenqingZixiangEntity::getShifouYitongguo, "yes")
                .isNotNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRen)
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getGuihuanRen)
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getDeleteMark);
        List<DmsDanganJieyueFuyinShenqingZixiangEntity> details = zixiangMapper.selectList(query);
        if (details.isEmpty()) {
            throw new DataException("未找到可归还的档案借阅复印子项");
        }
        if (details.size() > 1) {
            throw new DataException("档案盒编号关联多条可归还的档案借阅复印子项，请使用档案盒ID校验");
        }
        return toCheckVO(details.get(0));
    }

    private List<DmsDanganJieyueFuyinShenqingZixiangEntity> findDetails(Set<String> detailIds)
            throws DataException {
        LambdaQueryWrapper<DmsDanganJieyueFuyinShenqingZixiangEntity> query = new LambdaQueryWrapper<>();
        query.in(DmsDanganJieyueFuyinShenqingZixiangEntity::getId, detailIds)
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getDeleteMark);
        List<DmsDanganJieyueFuyinShenqingZixiangEntity> details = zixiangMapper.selectList(query);
        if (details.size() != detailIds.size()) {
            throw new DataException("存在未找到或已删除的档案借阅复印子项，无法归还");
        }
        return details;
    }

    private void ensureNotReturned(List<DmsDanganJieyueFuyinShenqingZixiangEntity> details)
            throws DataException {
        for (DmsDanganJieyueFuyinShenqingZixiangEntity detail : details) {
            if (!trimToEmpty(detail.getGuihuanRen()).isEmpty()) {
                throw new DataException("档案借阅复印子项已归还，不能重复归还");
            }
        }
    }

    private DmsDanganJieyueFuyinGuihuanCheckVO toCheckVO(DmsDanganJieyueFuyinShenqingZixiangEntity detail) {
        DmsDanganJieyueFuyinGuihuanCheckVO result = new DmsDanganJieyueFuyinGuihuanCheckVO();
        result.setId(detail.getId());
        result.setDanganheId(detail.getDanganheId());
        result.setDanganheBianhao(detail.getDanganheBianhao());
        result.setDanganheMingcheng(detail.getDanganheMingcheng());
        result.setShenqingRen(detail.getShenqingRen());
        result.setShenqingBumen(detail.getShenqingBumen());
        result.setJieshouRen(detail.getJieshouRen());
        result.setJieshouBumen(detail.getJieshouBumen());
        return result;
    }

    private Set<String> resolveDanganheIds(List<DmsDanganJieyueFuyinShenqingZixiangEntity> details)
            throws DataException {
        Set<String> ids = new LinkedHashSet<>();
        for (DmsDanganJieyueFuyinShenqingZixiangEntity detail : details) {
            ids.add(requireValue(detail.getDanganheId(), "档案借阅复印子项danganhe_id"));
        }
        return ids;
    }

    private Set<String> resolveIds(List<DmsDanganJieyueFuyinGuihuanForm> forms) throws DataException {
        if (forms == null || forms.isEmpty()) {
            throw new DataException("档案借阅复印归还参数不能为空");
        }
        Set<String> ids = new LinkedHashSet<>();
        for (DmsDanganJieyueFuyinGuihuanForm form : forms) {
            if (form == null) {
                throw new DataException("档案借阅复印归还参数中不能包含空记录");
            }
            String fId = requireValue(form.getFId(), "档案借阅复印子项f_id");
            String id = trimToEmpty(form.getId());
            if (!id.isEmpty() && !id.equals(fId)) {
                throw new DataException("档案借阅复印子项id与f_id不一致");
            }
            if (!ids.add(fId)) {
                throw new DataException("档案借阅复印归还参数中不能包含重复f_id");
            }
        }
        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();
    }

    private String trimToNull(String value) {
        String resolved = trimToEmpty(value);
        return resolved.isEmpty() ? null : resolved;
    }
}