package jnpf.flowable.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.base.entity.VisualdevEntity;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.TaskEntity;
import jnpf.flowable.mapper.FilePermissionSnapshotMapper;
import jnpf.flowable.model.filepermission.FilePermissionTaskState;
import jnpf.flowable.model.filepermission.FilePermissionPolicy;
import jnpf.flowable.enums.NodeEnum;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.util.ServiceUtil;
import jnpf.flowable.util.filepermission.FilePermissionPolicyCompiler;
import jnpf.flowable.util.filepermission.FilePermissionSnapshot;
import jnpf.util.UserProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.*;

/** 只扩展原生任务 INSERT 的快照内容，绝不在已有任务读写时补启用新规则。 */
@Service
@RequiredArgsConstructor
public class FilePermissionSnapshotService {
    /** 仅成功查库且完全无任务行时产生；查询失败或已删除任务不能冒充菜单草稿。 */
    public static final class TaskNotFoundException extends IllegalArgumentException { }
    private static final ObjectMapper JSON = new ObjectMapper();
    private final FilePermissionSnapshotMapper mapper;
    private final ServiceUtil serviceUtil;

    /** 只能由原生“新任务”分支调用；返回值与任务在同一 INSERT 中持久化。 */
    public void prepareNewTask(TaskEntity task, String sourceFlowId, Map<String, NodeModel> nodes) throws WorkFlowException {
        try {
            Map<String, Object> policy = FilePermissionPolicyCompiler.compile(nodes, this::loadForm, task.getFlowType());
            if (FilePermissionPolicy.parse(policy).isEmpty()) {
                task.setFilePermissionSnapshot(null);
                return;
            }
            String created = FilePermissionSnapshot.create(tenantId(), task.getId(), sourceFlowId, policy);
            List<String> starts = new ArrayList<>();
            for (Map.Entry<String, NodeModel> entry : nodes.entrySet()) {
                NodeModel node = entry.getValue();
                if (node != null && NodeEnum.START.getType().equals(node.getType())) {
                    starts.add(node.getNodeId() == null || node.getNodeId().trim().isEmpty() ? entry.getKey() : node.getNodeId());
                }
            }
            task.setFilePermissionSnapshot(FilePermissionSnapshot.read(created, tenantId(), task.getId()).withEnteredNodes(starts));
        } catch (RuntimeException e) {
            // 原生提交在 WorkFlowException 分支补偿已启动的引擎实例；读取配置失败同样进入该分支。
            throw configurationError(e);
        }
    }

    /** 在原生发布入口、引擎部署之前校验；不写表单或接管流程发布。 */
    public void validateConfiguration(Map<String, NodeModel> nodes, Integer flowType) throws WorkFlowException {
        try { FilePermissionPolicyCompiler.compile(nodes, this::loadForm, flowType); }
        catch (RuntimeException e) { throw configurationError(e); }
    }

    /** 内部读取不代表用户有访问任务的权限；调用方仍须原生准入与附件归属检查。 */
    public FilePermissionSnapshot find(String taskId) {
        if (taskId == null || taskId.trim().isEmpty()) throw new IllegalArgumentException("缺少流程任务标识");
        FilePermissionTaskState state = mapper.find(taskId);
        if (state == null) throw new TaskNotFoundException();
        if (!taskId.equals(state.getTaskId()) || state.getDeleteMark() != null) throw new IllegalArgumentException("流程任务不可用");
        return FilePermissionSnapshot.read(state.getSnapshot(), tenantId(), taskId);
    }

    public void prepareDerivedTask(TaskEntity task, String sourceTaskId) throws WorkFlowException {
        try {
            FilePermissionSnapshot source = find(sourceTaskId);
            task.setFilePermissionSnapshot(source == null ? null : source.forDerivedTask(task.getId()));
        } catch (IllegalArgumentException e) {
            throw new WorkFlowException("无法读取来源流程的文件权限：" + e.getMessage());
        }
    }

    /** 在原生节点激活路径内单调追加；CAS 防止并行激活互相覆盖。 */
    public void markEntered(String taskId, Collection<String> nodeIds) throws WorkFlowException {
        if (nodeIds == null || nodeIds.isEmpty()) return;
        update(taskId, snapshot -> snapshot.withEnteredNodes(nodeIds), "无法记录流程文件权限节点状态：");
    }

    /** 与原生退回使用同一后续节点集合；只有本轮被作废的触发节点才解除持续规则。 */
    public void markReturnedPast(String taskId, Collection<String> invalidatedNodeIds) throws WorkFlowException {
        if (invalidatedNodeIds == null || invalidatedNodeIds.isEmpty()) return;
        update(taskId, snapshot -> snapshot.withReturnedPastNodes(invalidatedNodeIds), "无法更新退回后的文件权限：");
    }

    private void update(String taskId, java.util.function.Function<FilePermissionSnapshot, String> change,
                        String errorPrefix) throws WorkFlowException {
        try {
            for (int attempt = 0; attempt < 3; attempt++) {
                FilePermissionTaskState state = mapper.find(taskId);
                if (state == null || state.getDeleteMark() != null) throw new IllegalArgumentException("流程任务不可用");
                if (state.getSnapshot() == null) return;
                FilePermissionSnapshot snapshot = FilePermissionSnapshot.read(state.getSnapshot(), tenantId(), taskId);
                String updated = change.apply(snapshot);
                if (updated.equals(state.getSnapshot()) || mapper.compareAndSetSnapshot(taskId, state.getSnapshot(), updated) == 1) return;
            }
            throw new IllegalArgumentException("流程节点状态已变化，请重试");
        } catch (RuntimeException e) {
            throw new WorkFlowException(errorPrefix + e.getMessage());
        }
    }

    private Map<String, Object> loadForm(String id) {
        VisualdevEntity form = serviceUtil.getReleaseInfo(id);
        if (form == null || form.getFormData() == null) throw new IllegalArgumentException("发布表单不存在");
        try { return JSON.readValue(form.getFormData(), new TypeReference<Map<String, Object>>() { }); }
        catch (java.io.IOException e) { throw new IllegalArgumentException("发布表单配置无效", e); }
    }

    private String tenantId() {
        String tenant = UserProvider.getUser().getTenantId();
        return tenant == null || tenant.trim().isEmpty() ? "0" : tenant;
    }

    private WorkFlowException configurationError(RuntimeException e) {
        return new WorkFlowException(e instanceof IllegalArgumentException
                ? "文件权限配置无效：" + e.getMessage() : "暂时无法读取流程文件权限配置，请稍后重试");
    }
}