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.DmsDanganJieyueFuyinShenqingZixiangEntity;
import jnpf.dmsEntity.form.DmsDanganJieyueFuyinJieshouForm;
import jnpf.dmsEntity.vo.DmsDanganJieyueFuyinJieshouCheckVO;
import jnpf.dmsMapper.DmsDanganJieyueFuyinShenqingZixiangMapper;
import jnpf.dmsPermission.DmsCurrentIdentity;
import jnpf.dmsService.DmsDanganJieyueFuyinJieshouService;
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.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

@Service
@RequiredArgsConstructor
public class DmsDanganJieyueFuyinJieshouServiceImpl implements DmsDanganJieyueFuyinJieshouService {

    private final DmsDanganJieyueFuyinShenqingZixiangMapper zixiangMapper;
    private final DmsCurrentIdentity currentIdentity;

    @Override
    @Transactional(rollbackFor = Exception.class)
    @AuditLog(
            action = "LOAN_COPY_RECEIVE",
            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 jieshou(List<DmsDanganJieyueFuyinJieshouForm> forms) throws DataException {
        Set<String> ids = resolveIds(forms);
        ensureNotReceived(ids);
        UserInfo user = currentIdentity.requireUser();
        String defaultUserId = requireValue(user.getUserId(), "当前用户");
        String defaultOrganizeId = trimToNull(user.getOrganizeId());
        Map<ReceiveValues, Set<String>> detailIdsByReceiveValues = resolveReceiveValues(
                forms, defaultUserId, defaultOrganizeId);

        for (Map.Entry<ReceiveValues, Set<String>> entry : detailIdsByReceiveValues.entrySet()) {
            ReceiveValues receiveValues = entry.getKey();
            Set<String> detailIds = entry.getValue();
            LambdaUpdateWrapper<DmsDanganJieyueFuyinShenqingZixiangEntity> update = new LambdaUpdateWrapper<>();
            update.in(DmsDanganJieyueFuyinShenqingZixiangEntity::getId, detailIds)
                    .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getDeleteMark)
                    .and(wrapper -> wrapper.isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRen)
                            .or()
                            .eq(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRen, ""))
                    .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRen, receiveValues.jieshouRen)
                    .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRiqi, new Date())
                    .set(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouBumen, receiveValues.jieshouBumen);
            if (zixiangMapper.update(null, update) != detailIds.size()) {
                throw new DataException("档案借阅复印子项已接收，不能重复接收");
            }
        }
    }

    private Map<ReceiveValues, Set<String>> resolveReceiveValues(List<DmsDanganJieyueFuyinJieshouForm> forms,
            String defaultUserId, String defaultOrganizeId) {
        Map<ReceiveValues, Set<String>> result = new LinkedHashMap<>();
        for (DmsDanganJieyueFuyinJieshouForm form : forms) {
            ReceiveValues values = new ReceiveValues(
                    valueOrDefault(form.getJieshouRen(), defaultUserId),
                    valueOrDefault(form.getJieshouBumen(), defaultOrganizeId));
            Set<String> detailIds = result.get(values);
            if (detailIds == null) {
                detailIds = new LinkedHashSet<>();
                result.put(values, detailIds);
            }
            detailIds.add(form.getFId().trim());
        }
        return result;
    }

    @Override
    @Transactional(readOnly = true)
    public DmsDanganJieyueFuyinJieshouCheckVO 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")
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getJieshouRen)
                .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 void ensureNotReceived(Set<String> ids) throws DataException {
        LambdaQueryWrapper<DmsDanganJieyueFuyinShenqingZixiangEntity> query = new LambdaQueryWrapper<>();
        query.in(DmsDanganJieyueFuyinShenqingZixiangEntity::getId, ids)
                .isNull(DmsDanganJieyueFuyinShenqingZixiangEntity::getDeleteMark);
        List<DmsDanganJieyueFuyinShenqingZixiangEntity> details = zixiangMapper.selectList(query);
        if (details.size() != ids.size()) {
            throw new DataException("存在未找到或已删除的档案借阅复印子项，无法接收");
        }
        for (DmsDanganJieyueFuyinShenqingZixiangEntity detail : details) {
            if (!trimToEmpty(detail.getJieshouRen()).isEmpty()) {
                throw new DataException("档案借阅复印子项已接收，不能重复接收");
            }
        }
    }

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

    private Set<String> resolveIds(List<DmsDanganJieyueFuyinJieshouForm> forms) throws DataException {
        if (forms == null || forms.isEmpty()) {
            throw new DataException("档案借阅复印接收参数不能为空");
        }
        Set<String> ids = new LinkedHashSet<>();
        for (DmsDanganJieyueFuyinJieshouForm 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;
    }

    private String valueOrDefault(String value, String defaultValue) {
        String resolved = trimToNull(value);
        return resolved == null ? defaultValue : resolved;
    }

    private static class ReceiveValues {
        private final String jieshouRen;
        private final String jieshouBumen;

        private ReceiveValues(String jieshouRen, String jieshouBumen) {
            this.jieshouRen = jieshouRen;
            this.jieshouBumen = jieshouBumen;
        }

        @Override
        public boolean equals(Object other) {
            if (this == other) {
                return true;
            }
            if (!(other instanceof ReceiveValues)) {
                return false;
            }
            ReceiveValues that = (ReceiveValues) other;
            return Objects.equals(jieshouRen, that.jieshouRen)
                    && Objects.equals(jieshouBumen, that.jieshouBumen);
        }

        @Override
        public int hashCode() {
            return Objects.hash(jieshouRen, jieshouBumen);
        }
    }
}