package jnpf.flowable.service.dev;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import jnpf.base.UserInfo;
import jnpf.base.entity.VisualdevEntity;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.OperatorEntity;
import jnpf.flowable.entity.TemplateNodeEntity;
import jnpf.flowable.enums.NodeEnum;
import jnpf.flowable.enums.OperatorStateEnum;
import jnpf.flowable.enums.TaskStatusEnum;
import jnpf.flowable.model.candidates.CandidateCheckFo;
import jnpf.flowable.model.candidates.CandidateCheckVo;
import jnpf.flowable.model.task.FlowModel;
import jnpf.flowable.model.templatenode.nodejson.FormMappingConfig;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.*;
import jnpf.flowable.service.OperatorService;
import jnpf.flowable.service.TaskService;
import jnpf.flowable.util.FlowUtil;
import jnpf.flowable.util.OperatorUtil;
import jnpf.flowable.util.ServiceUtil;
import jnpf.permission.entity.UserEntity;
import jnpf.util.UserProvider;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;

/** Validates and advances one native operator; DevApprovalRuns owns the bounded background sequence. */
@Service
@RequiredArgsConstructor
@lombok.extern.slf4j.Slf4j
public class DevApprovalService {
    private final DevApprovalProperties properties;
    private final FlowUtil flowUtil;
    private final OperatorUtil operatorUtil;
    private final OperatorService operatorService;
    private final TaskService taskService;
    private final ServiceUtil serviceUtil;
    private final DevApprovalLocks redisLock;
    private final DevApprovalStep step;
    private final DevApprovalSignatures signatures;
    private final jnpf.base.DictionaryDataApi dictionaries;

    @Data
    public static class State {
        private boolean enabled;
        private String status = "BLOCKED";
        private String operatorId;
        private String nodeName;
        private List<String> problems = new ArrayList<>();
    }

    private static class Prepared {
        final State state = new State();
        final FlowModel model = new FlowModel();
        OperatorEntity operator;
    }

    public State inspect(String taskId, String signId) throws WorkFlowException {
        if (!allowed()) return new State();
        try {
            DevApprovalSignature sign = signId == null || signId.isBlank() ? null : signatures.require(taskId, signId);
            return prepare(taskId, sign).state;
        } finally { clearContext(); }
    }

    boolean allowed() {
        UserInfo user = UserProvider.getUser();
        return properties.available() && user != null && Boolean.TRUE.equals(user.getIsAdministrator());
    }

    public State approve(String taskId, String expectedOperatorId, String signId) throws WorkFlowException {
        if (!allowed()) throw new WorkFlowException("开发审核未启用或当前用户不是管理员");
        if (expectedOperatorId != null && expectedOperatorId.isBlank()) throw new WorkFlowException("缺少待办标识，请刷新后重试");
        DevApprovalSignature signature = signatures.require(taskId, signId);
        String token = UUID.randomUUID().toString();
        String taskLock = "dev-approve:" + taskId;
        if (!redisLock.lock(taskLock, token, 300, TimeUnit.SECONDS)) throw new WorkFlowException("此流程正在执行开发审核");
        long started = System.nanoTime();
        String nodeLock = null;
        try {
            Prepared prepared = prepare(taskId, signature, false);
            if (!"READY".equals(prepared.state.getStatus())) return prepared.state;
            if (expectedOperatorId != null && !expectedOperatorId.equals(prepared.operator.getId())) throw new WorkFlowException("待办已变化，请刷新后重试");
            String key = taskId + prepared.operator.getNodeId();
            if (!redisLock.lock(key, token, 300, TimeUnit.SECONDS)) throw new WorkFlowException("当前节点正在审批中，请稍后重试");
            nodeLock = key;
            // Re-read under the same node lock used by normal approval.
            prepared = prepare(taskId, signature);
            if (!"READY".equals(prepared.state.getStatus())) return prepared.state;
            if (!key.equals(taskId + prepared.operator.getNodeId())) throw new WorkFlowException("待办节点已变化，请重新查看流程");
            if (expectedOperatorId != null && !expectedOperatorId.equals(prepared.operator.getId())) throw new WorkFlowException("待办已变化，请刷新后重试");
            FlowModel model = prepared.model;
            try {
                step.approve(prepared.operator, model, signature.getUserId());
            } catch (Exception e) {
                try {
                    operatorUtil.compensate(model.getTaskEntity());
                } catch (Exception recoveryFailure) {
                    e.addSuppressed(recoveryFailure);
                    log.error("开发审批失败且待办恢复失败 task={}", taskId, e);
                    throw new WorkFlowException("审批失败且待办恢复未完成，请先核对流程状态；原错误：" + e.getMessage());
                }
                if (e instanceof WorkFlowException && "任务不存在".equals(e.getMessage())) {
                    log.warn("开发审批使用的引擎待办已失效，原生补偿已完成 task={}", taskId, e);
                    throw new WorkFlowException("当前引擎待办已失效，系统已执行待办恢复；本次未完成审批，请刷新流程并重新签名后重试");
                }
                throw e;
            }
            operatorUtil.handleOperator();
            operatorUtil.handleTaskStatusThenEvent();
            // Each manual node is preflighted on the next background step; don't sweep unchecked nodes via autoAudit.
            operatorUtil.launchTrigger(model);
            operatorUtil.handleTaskStatus();
            State result = new State();
            result.setEnabled(true);
            result.setOperatorId(prepared.operator.getId());
            result.setNodeName(prepared.state.getNodeName());
            result.setStatus(Objects.equals(taskService.getInfo(taskId).getStatus(), TaskStatusEnum.PASSED.getCode())
                    ? "PASSED" : "ADVANCED");
            return result;
        } finally {
            log.info("开发审批单步结束 task={} elapsedMs={}", taskId, (System.nanoTime() - started) / 1_000_000);
            clearContext();
            if (nodeLock != null) redisLock.unlock(nodeLock, token);
            redisLock.unlock(taskLock, token);
        }
    }

    private Prepared prepare(String taskId, DevApprovalSignature signature) throws WorkFlowException {
        return prepare(taskId, signature, true);
    }

    private Prepared prepare(String taskId, DevApprovalSignature signature, boolean full) throws WorkFlowException {
        Prepared prepared = new Prepared();
        flowUtil.setFlowModel(taskId, prepared.model);
        TemplateNodeEntity start = prepared.model.getNodeEntityList().stream()
                .filter(n -> NodeEnum.START.getType().equals(n.getNodeType())).findFirst().orElse(null);
        if (start == null || !properties.allowsForm(start.getFormId())) return prepared;
        prepared.state.setEnabled(true);
        Integer status = prepared.model.getTaskEntity().getStatus();
        if (Objects.equals(status, TaskStatusEnum.PASSED.getCode())) {
            prepared.state.setStatus("PASSED");
            return prepared;
        }
        if (!Objects.equals(status, TaskStatusEnum.RUNNING.getCode()) || prepared.model.getTaskEntity().getRejectDataId() != null) {
            prepared.state.getProblems().add("仅支持正常进行中的流程；请先处理暂停、退回或撤销状态");
            return prepared;
        }
        // Button discovery must not depend on form data or candidate calculation.
        // Signed inspection and every approval still perform the full preflight below.
        if (signature == null) {
            prepared.state.setStatus("READY");
            return prepared;
        }
        prepared.operator = operatorService.getList(taskId).stream().filter(DevApprovalService::pending)
                .sorted(Comparator.comparing(OperatorEntity::getId)).findFirst().orElse(null);
        if (prepared.operator == null) {
            prepared.state.getProblems().add("当前没有可自动推进的待办，可能正在等待子流程、触发器或外部事件");
            return prepared;
        }
        OperatorEntity operator = prepared.operator;
        prepared.state.setOperatorId(operator.getId());
        prepared.state.setNodeName(operator.getNodeName());
        if (!full) {
            prepared.state.setStatus("READY");
            return prepared;
        }
        try (DevApprovalActor ignored = DevApprovalActor.open(operator.getId(), signature.getUserId(), taskId)) {
            NodeModel node = prepared.model.getNodes().get(operator.getNodeCode());
            TemplateNodeEntity definition = prepared.model.getNodeEntityList().stream()
                    .filter(n -> operator.getNodeCode().equals(n.getNodeCode())).findFirst().orElse(null);
            List<String> problems = prepared.state.getProblems();
            if (node == null || definition == null || !properties.allowsForm(definition.getFormId())) {
                problems.add("当前节点表单不在开发审核允许范围内");
                return prepared;
            }
            if (!NodeEnum.APPROVER.getType().equals(node.getType()) && !NodeEnum.PROCESSING.getType().equals(node.getType())) {
                problems.add("当前节点不是审批或办理节点");
                return prepared;
            }
            if (Boolean.TRUE.equals(node.getHasSign())) problems.add("当前节点还要求手写签名图片，电子签名凭证不能代替图片，请通过正常入口完成此节点");
            if (Boolean.TRUE.equals(node.getIsCustomCopy())) problems.add("当前节点需要人工选择抄送人");
            JSONObject raw = JSON.parseObject(definition.getNodeJson());
            JSONObject approve = raw.getJSONObject("approveFuncConfig");
            if (approve != null && approve.getJSONObject("validateFuncConfig") != null
                    && Boolean.TRUE.equals(approve.getJSONObject("validateFuncConfig").getBoolean("on"))) {
                problems.add("当前节点配置了前端自定义审批校验，请通过正常审核入口完成");
            }
            Map<String, Object> saved = serviceUtil.infoData(definition.getFormId(), taskId);
            if (saved == null || saved.isEmpty()) {
                problems.add("未能读取已保存的表单数据");
                return prepared;
            }
            String actorId = signature.getUserId();
            String opinion = "开发测试一键审核；签名用户：" + actorId + "；电子签名："
                    + signature.getId() + "；原待办人：" + operator.getHandleId();
            Map<String, Object> effective = JSON.parseObject(JSON.toJSONString(saved));
            if (operator.getDraftData() != null && !operator.getDraftData().isBlank()) {
                Map<String, Object> draft = JSON.parseObject(operator.getDraftData());
                Object draftVersion = draft.get("f_version");
                if (draftVersion != null && saved.get("f_version") != null
                        && !draftVersion.toString().equals(saved.get("f_version").toString())) {
                    problems.add("节点暂存数据版本已变化，请先在正常表单中核对并保存");
                    return prepared;
                }
                draft.forEach((key, value) -> { if (!"f_version".equals(key)) effective.put(key, value); });
            }
            UserEntity signer = serviceUtil.getUserInfo(actorId);
            if (signer == null || !Objects.equals(signer.getEnabledMark(), 1) || signer.getDeleteMark() != null) {
                problems.add("签名用户不存在或已停用");
                return prepared;
            }
            VisualdevEntity released = serviceUtil.getReleaseInfo(definition.getFormId());
            if (released == null || released.getFormData() == null) {
                problems.add("无法读取已发布表单控件配置");
                return prepared;
            }
            String bizSign = signature.getId();
            effective.put("biz_sign", bizSign);
            Map<String, com.alibaba.fastjson.JSONArray> options = new HashMap<>();
            problems.addAll(DevApprovalFill.fill(node, released.getFormData(), effective, signer, bizSign,
                    type -> options.computeIfAbsent(type, key -> {
                        var items = dictionaries.getList(key, "true");
                        return items == null ? new com.alibaba.fastjson.JSONArray() : (com.alibaba.fastjson.JSONArray) JSON.toJSON(items);
                    })));
            FormMappingConfig mapping = node.getFormMapping();
            if (mapping != null && Boolean.TRUE.equals(mapping.getFillToForm())) {
                put(effective, mapping.getOpinionField(), opinion);
                put(effective, mapping.getOperatorField(), actorId);
                put(effective, mapping.getDateField(), System.currentTimeMillis());
                put(effective, mapping.getDepartmentField(), signer.getOrganizeId());
                put(effective, mapping.getFileField(), Collections.emptyList());
            }
            if (!problems.isEmpty()) return prepared;
            CandidateCheckFo candidates = new CandidateCheckFo();
            candidates.setId(taskId);
            candidates.setFlowId(prepared.model.getTaskEntity().getFlowId());
            candidates.setFormData(effective);
            CandidateCheckVo next = taskService.checkCandidates(operator.getId(), candidates);
            if (next == null || (!Objects.equals(next.getType(), 3) && !Objects.equals(next.getType(), 2))) {
                problems.add("下一步需要人工选择分支或自由审批，请先处理此节点");
                return prepared;
            }
            if (Objects.equals(next.getType(), 2)) {
                if (next.getList() == null || next.getList().isEmpty()) {
                    problems.add("候选节点配置为空，无法确定下一步");
                    return prepared;
                }
                for (var choice : next.getList()) {
                    if (Boolean.TRUE.equals(choice.getIsCandidates()))
                        prepared.model.getCandidateList().put(choice.getNodeCode(), List.of(actorId));
                }
            }
            prepared.model.setFormData(effective);
            prepared.model.setHandleStatus(FlowNature.AUDIT_COMPLETION);
            prepared.model.setHandleOpinion(opinion);
            operatorUtil.getGlobalParam(prepared.model.getTaskEntity(), node,
                    prepared.model.getNodes().get(NodeEnum.GLOBAL.getType()), effective);
            prepared.state.setStatus("READY");
            return prepared;
        }
    }

    static void clearContext() {
        FlowContextHolder.clearAll();
        FlowOperatorHolder.clear();
        FlowStatusHolder.clear();
        FlowEventHolder.clear();
        SystemAuditHolder.clear();
        TriggerHolder.clear();
        TriggerRecordHolder.clear();
    }

    static boolean pending(OperatorEntity operator) {
        return operator.getHandleStatus() == null && !Objects.equals(operator.getCompletion(), FlowNature.ACTION)
                && Arrays.asList(OperatorStateEnum.RUNING.getCode(), OperatorStateEnum.ADD_SIGN.getCode(),
                OperatorStateEnum.TRANSFER.getCode(), OperatorStateEnum.ASSIGNED.getCode(),
                OperatorStateEnum.TRANSFER_PROCESSING.getCode()).contains(operator.getStatus());
    }

    private static void put(Map<String, Object> data, String field, Object value) {
        if (field != null && !field.isBlank()) data.put(field, value);
    }
}