package jnpf.elnService.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jnpf.base.UserInfo;
import jnpf.database.util.TenantDataSourceUtil;
import jnpf.elnEntity.runtime.ElnRecordEntity;
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
import jnpf.elnEntity.runtime.ElnRecordFormulaCalculationResult;
import jnpf.elnEntity.runtime.ElnRecordRepeatValueEntity;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.elnMapper.ElnRecordFieldValueMapper;
import jnpf.elnMapper.ElnRecordMapper;
import jnpf.elnMapper.ElnRecordRepeatValueMapper;
import jnpf.elnMapper.ElnRecordRevisionMapper;
import jnpf.elnService.ElnTestWorkItemSnapshotProvider;
import jnpf.elnService.ElnRecordFormulaCalculationService;
import jnpf.elnService.ElnRecordRecalculationService;
import jnpf.exception.DataException;
import jnpf.lims.api.model.TestWorkItemSnapshotBatch;
import jnpf.lims.api.model.TestWorkItemSnapshot;
import jnpf.model.tenant.TenantVO;
import jnpf.util.UserProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.Collections;
import java.util.List;

@Service
public class ElnRecordRecalculationServiceImpl
        implements ElnRecordRecalculationService {

    private final ElnRecordMapper recordMapper;
    private final ElnRecordRevisionMapper revisionMapper;
    private final ElnRecordFieldValueMapper valueMapper;
    private final ElnRecordRepeatValueMapper repeatValueMapper;
    private final ElnTestWorkItemSnapshotProvider taskProvider;
    private final ElnRecordFormulaCalculationService calculationService;
    private final CurrentUserProvider currentUserProvider;

    @Autowired
    public ElnRecordRecalculationServiceImpl(
            ElnRecordMapper recordMapper,
            ElnRecordRevisionMapper revisionMapper,
            ElnRecordFieldValueMapper valueMapper,
            ElnRecordRepeatValueMapper repeatValueMapper,
            ElnTestWorkItemSnapshotProvider taskProvider,
            ElnRecordFormulaCalculationService calculationService) {
        this(recordMapper, revisionMapper, valueMapper, repeatValueMapper, taskProvider,
                calculationService, ElnRecordRecalculationServiceImpl::currentUser);
    }

    ElnRecordRecalculationServiceImpl(
            ElnRecordMapper recordMapper,
            ElnRecordRevisionMapper revisionMapper,
            ElnRecordFieldValueMapper valueMapper,
            ElnTestWorkItemSnapshotProvider taskProvider,
            ElnRecordFormulaCalculationService calculationService,
            CurrentUserProvider currentUserProvider) {
        this(recordMapper, revisionMapper, valueMapper, null, taskProvider,
                calculationService, currentUserProvider);
    }

    ElnRecordRecalculationServiceImpl(
            ElnRecordMapper recordMapper,
            ElnRecordRevisionMapper revisionMapper,
            ElnRecordFieldValueMapper valueMapper,
            ElnRecordRepeatValueMapper repeatValueMapper,
            ElnTestWorkItemSnapshotProvider taskProvider,
            ElnRecordFormulaCalculationService calculationService,
            CurrentUserProvider currentUserProvider) {
        this.recordMapper = recordMapper;
        this.revisionMapper = revisionMapper;
        this.valueMapper = valueMapper;
        this.repeatValueMapper = repeatValueMapper;
        this.taskProvider = taskProvider;
        this.calculationService = calculationService;
        this.currentUserProvider = currentUserProvider;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ElnRecordVos.Recalculated recalculateAll(
            String recordId, ElnRecordForms.Recalculate command) {
        String actualRecordId = required(recordId, "电子记录不能为空");
        String operationCode = required(
                command == null ? null : command.getOperationCode(), "计算操作码不能为空");
        Integer expectedVersion = command == null ? null : command.getExpectedRecordVersion();
        if (expectedVersion == null || expectedVersion < 0) {
            throw new DataException("电子记录版本不能为空");
        }
        UserContext user = currentUserProvider.get();
        ElnRecordEntity record = recordMapper.selectOne(
                Wrappers.<ElnRecordEntity>lambdaQuery()
                        .eq(ElnRecordEntity::getFTenantId, user.tenantId)
                        .eq(ElnRecordEntity::getId, actualRecordId)
                        .and(q -> q.isNull(ElnRecordEntity::getFDeleteMark)
                                .or().eq(ElnRecordEntity::getFDeleteMark, 0)).last("limit 1"));
        if (record == null || !StringUtils.hasText(record.getDangqianXiudingId())) {
            throw new DataException("电子记录不存在或当前修订无效");
        }
        ElnRecordRevisionEntity revision = revisionMapper.selectOne(
                Wrappers.<ElnRecordRevisionEntity>lambdaQuery()
                        .eq(ElnRecordRevisionEntity::getFTenantId, user.tenantId)
                        .eq(ElnRecordRevisionEntity::getId, record.getDangqianXiudingId())
                        .eq(ElnRecordRevisionEntity::getDianziJiluId, record.getId())
                        .and(q -> q.isNull(ElnRecordRevisionEntity::getFDeleteMark)
                                .or().eq(ElnRecordRevisionEntity::getFDeleteMark, 0)).last("limit 1"));
        if (revision == null || !"DRAFT".equals(revision.getBizStatus())) {
            throw new DataException("电子记录当前修订不允许重新计算");
        }
        assertTaskAccess(record);
        if (!expectedVersion.equals(record.getFVersion())
                || recordMapper.advanceVersion(user.tenantId, record.getId(),
                        expectedVersion, user.userId) != 1) {
            throw new DataException("电子记录已被其他操作更新");
        }
        List<ElnRecordFieldValueEntity> values = valueMapper.selectList(
                Wrappers.<ElnRecordFieldValueEntity>lambdaQuery()
                        .eq(ElnRecordFieldValueEntity::getFTenantId, user.tenantId)
                        .eq(ElnRecordFieldValueEntity::getDianziJiluId, record.getId())
                        .eq(ElnRecordFieldValueEntity::getXiudingId, revision.getId())
                        .and(q -> q.isNull(ElnRecordFieldValueEntity::getFDeleteMark)
                                .or().eq(ElnRecordFieldValueEntity::getFDeleteMark, 0)));
        ElnRecordFormulaCalculationResult calculated = calculationService.recalculateAllWithRepeats(
                user.tenantId, record, revision, values, operationCode, user.userId);
        for (ElnRecordFieldValueEntity value : calculated.getFieldValues()) {
            if (valueMapper.updateById(value) != 1) {
                throw new DataException("公式结果字段保存冲突");
            }
        }
        for (ElnRecordRepeatValueEntity value : calculated.getRepeatValues()) {
            if (repeatValueMapper == null || repeatValueMapper.updateById(value) != 1) {
                throw new DataException("重复公式结果字段保存冲突");
            }
        }
        return result(record, revision, operationCode, expectedVersion + 1, calculated);
    }

    private void assertTaskAccess(ElnRecordEntity record) {
        TestWorkItemSnapshotBatch batch = taskProvider.resolve(
                Collections.singletonList(record.getJianyanXiangId()),
                Collections.<String>emptyList());
        if (batch == null || batch.getItems() == null || batch.getItems().size() != 1) {
            throw new DataException("LIMS 检验任务快照返回无效");
        }
        TestWorkItemSnapshot item = batch.getItems().get(0);
        if (item == null || !record.getJianyanXiangId().equals(item.getTestWorkItemId())
                || !"SUCCESS".equals(item.getOutcomeCode())) {
            throw new DataException(item != null && StringUtils.hasText(item.getReason())
                    ? item.getReason() : "当前用户或检验项状态不允许重新计算电子记录");
        }
    }

    private static ElnRecordVos.Recalculated result(
            ElnRecordEntity record, ElnRecordRevisionEntity revision,
            String operationCode, int recordVersion,
            ElnRecordFormulaCalculationResult calculated) {
        ElnRecordVos.Recalculated result = new ElnRecordVos.Recalculated();
        result.setRecordId(record.getId());
        result.setRevisionId(revision.getId());
        result.setOperationCode(operationCode);
        result.setRecordVersion(recordVersion);
        List<String> statuses = new java.util.ArrayList<>();
        for (ElnRecordFieldValueEntity value : calculated.getFieldValues()) {
            statuses.add(value.getJisuanZhuangtai());
        }
        for (ElnRecordRepeatValueEntity value : calculated.getRepeatValues()) {
            statuses.add(value.getJisuanZhuangtai());
        }
        for (String status : statuses) {
            if ("SUCCESS".equals(status)) {
                result.setSuccessCount(result.getSuccessCount() + 1);
            } else if ("MISSING_INPUT".equals(status)) {
                result.setMissingInputCount(result.getMissingInputCount() + 1);
            } else {
                result.setErrorCount(result.getErrorCount() + 1);
            }
        }
        return result;
    }

    private static String required(String value, String message) {
        if (!StringUtils.hasText(value)) throw new DataException(message);
        return value.trim();
    }

    private static UserContext currentUser() {
        UserInfo user = UserProvider.getUser();
        if (user == null || !StringUtils.hasText(user.getUserId())) {
            throw new DataException("当前登录用户无效");
        }
        TenantVO routed = TenantDataSourceUtil.getTenantInfo();
        String tenantId = routed != null && StringUtils.hasText(routed.getEnCode())
                ? routed.getEnCode().trim() : user.getTenantId();
        return new UserContext(StringUtils.hasText(tenantId) ? tenantId.trim() : "0",
                user.getUserId().trim());
    }

    @FunctionalInterface
    interface CurrentUserProvider {
        UserContext get();
    }

    static final class UserContext {
        private final String tenantId;
        private final String userId;

        UserContext(String tenantId, String userId) {
            this.tenantId = tenantId;
            this.userId = userId;
        }
    }
}