package jnpf.dmsService;

import jnpf.base.entity.VisualdevEntity;
import jnpf.flowable.WorkFlowApi;
import jnpf.flowable.entity.TemplateJsonEntity;
import jnpf.flowable.entity.TemplateNodeEntity;
import jnpf.flowable.enums.NodeEnum;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.onlinedev.VisualdevOnlineApi;
import jnpf.util.JsonUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/** Discovers fields from configured published workflows using the shared display schema. */
@org.springframework.stereotype.Service
@RequiredArgsConstructor
@Slf4j
public class DmsQianpiyeCatalogService {

    private final jnpf.dmsService.DmsQianpiyeProperties properties;
    private final WorkFlowApi workFlowApi;
    private final VisualdevOnlineApi visualdevOnlineApi;
    private final DmsQianpiyeDocxPropertiesReader docxPropertiesReader;

    public Map<String, Object> load() {
        return load(Collections.emptyMap());
    }

    public Map<String, Object> loadForDocument(String fileType, String fileId, boolean refresh) {
        Map<String, String> saved = refresh ? Collections.emptyMap() : docxPropertiesReader.read(fileType, fileId);
        return load(DmsQianpiyeDocxPropertiesReader.hasCompleteFlowVersions(saved) ? saved : Collections.emptyMap());
    }

    private Map<String, Object> load(Map<String, String> savedVersions) {
        List<FlowCatalog> catalogs = new ArrayList<>();
        List<Map<String, Object>> fieldCatalog = new ArrayList<>();
        Map<String, String> publishedVersions = new LinkedHashMap<>();
        for (jnpf.dmsService.DmsQianpiyeProperties.Flow configured : properties.getFlows()) {
            if (configured.getTemplateId() == null || configured.getTemplateId().isBlank())
                throw new jnpf.exception.DataException("签批页适用流程缺少模板 ID");
            FlowDefinition flow = new FlowDefinition(configured.getKey(), configured.getTemplateId());
            List<TemplateJsonEntity> versions = workFlowApi.getFlowIdsByTemplate(flow.templateId);
            String savedVersionId = "new".equals(flow.key)
                    ? DmsQianpiyeDocxPropertiesReader.newFlowVersionId(savedVersions)
                    : "revision".equals(flow.key)
                    ? DmsQianpiyeDocxPropertiesReader.revisionFlowVersionId(savedVersions) : null;
            TemplateJsonEntity version = resolveVersion(versions, savedVersionId, flow.key);
            if (version == null) {
                continue;
            }
            publishedVersions.put(configured.getKey(), version.getId());
            List<StepDefinition> steps = new ArrayList<>();
            Set<String> formIds = new LinkedHashSet<>();
            List<TemplateNodeEntity> nodes = DmsQianpiyeNodeOrder.order(version.getFlowXml(),
                    workFlowApi.getNodesByFlowId(version.getId()));
            for (TemplateNodeEntity node : nodes) {
                if (org.springframework.util.StringUtils.hasText(node.getFormId())) formIds.add(node.getFormId());
                String role = NodeEnum.START.getType().equals(node.getNodeType()) ? "START"
                        : NodeEnum.APPROVER.getType().equals(node.getNodeType()) ? "APPROVE" : null;
                if (role == null) {
                    continue;
                }
                NodeModel model = JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class);
                String nodeName = model == null || !org.springframework.util.StringUtils.hasText(model.getNodeName())
                        ? node.getNodeCode() : model.getNodeName();
                if (!org.springframework.util.StringUtils.hasText(nodeName)) {
                    continue;
                }
                steps.add(new StepDefinition(role, nodeName));
            }
            catalogs.add(new FlowCatalog(flow, steps, Collections.emptyList()));
            if (!"new".equals(flow.key) && !"revision".equals(flow.key)) {
                continue;
            }
            for (String formId : formIds) {
                VisualdevEntity form = visualdevOnlineApi.getFormConfig(formId);
                if (form == null) throw new jnpf.exception.DataException("表单配置不存在: " + formId);
                for (jnpf.onlinedev.model.FormDisplaySchema.Field field :
                        jnpf.onlinedev.model.FormDisplaySchema.parse(form.getFormData())) {
                    if (!field.isSupported()) {
                        continue;
                    }
                    Map<String, Object> item = new LinkedHashMap<>();
                    item.put("flowKey", flow.key);
                    item.put("key", field.getPath());
                    item.put("label", field.getLabel());
                    item.put("path", field.getPath());
                    item.put("table", field.getTable());
                    item.put("column", field.getColumn());
                    item.put("signature", field.displaySignature());
                    fieldCatalog.add(item);
                }
            }
        }
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("workflowSteps", mergeSteps(catalogs));
        result.put("formFields", mergeCompatibleFields(fieldCatalog));
        result.put("newFlowVersionId", publishedVersions.get("new"));
        result.put("revisionFlowVersionId", publishedVersions.get("revision"));
        return result;
    }

    private TemplateJsonEntity resolveVersion(List<TemplateJsonEntity> versions, String savedVersionId,
            String flowKey) {
        if (versions == null) versions = Collections.emptyList();
        if (org.springframework.util.StringUtils.hasText(savedVersionId)) {
            for (TemplateJsonEntity version : versions) {
                if (savedVersionId.equals(version.getId())) return version;
            }
            throw new jnpf.exception.DataException("签批页保存的" + flowKey + "流程版本不存在，请点击刷新后重新保存");
        }
        return versions.stream().filter(item -> Integer.valueOf(1).equals(item.getState()))
                .max((left, right) -> compareVersion(left.getVersion(), right.getVersion())).orElse(null);
    }

    private static List<Map<String, Object>> mergeCompatibleFields(List<Map<String, Object>> fields) {
        Map<String, List<Map<String, Object>>> grouped = new LinkedHashMap<>();
        for (Map<String, Object> field : fields)
            grouped.computeIfAbsent(String.valueOf(field.get("path")), key -> new ArrayList<>()).add(field);
        List<Map<String, Object>> result = new ArrayList<>();
        for (List<Map<String, Object>> group : grouped.values()) {
            Map<String, Object> first = group.get(0);
            Set<Object> flowKeys = new LinkedHashSet<>();
            for (Map<String, Object> field : group) {
                flowKeys.add(field.get("flowKey"));
            }
            if (!flowKeys.equals(Set.of("new", "revision"))) {
                continue;
            }
            boolean compatible = group.stream().allMatch(field ->
                    java.util.Objects.equals(first.get("signature"), field.get("signature")));
            if (!compatible) {
                continue;
            }
            Map<String, Object> common = new LinkedHashMap<>();
            common.put("key", first.get("path"));
            common.put("tag", "dms.qianpiye.form." + first.get("path"));
            common.put("label", first.get("label"));
            common.put("formId", "common");
            common.put("table", first.get("table"));
            common.put("column", first.get("column"));
            result.add(common);
        }
        return result;
    }

    /**
     * 节点编码只在单个流程版本中有效。签批页模板需要跨新增/修订复用，因此按角色内顺序生成稳定步骤键。
     */
    private static List<Map<String, String>> mergeSteps(List<FlowCatalog> catalogs) {
        Map<String, Map<String, String>> result = new LinkedHashMap<>();
        for (FlowCatalog catalog : catalogs) {
            List<Map<String, String>> steps = new ArrayList<>();
            appendMergedSteps(steps, "START", "start", stepsFor(catalog, "START"), Collections.emptyList());
            appendMergedSteps(steps, "APPROVE", "approve", stepsFor(catalog, "APPROVE"), Collections.emptyList());
            for (Map<String, String> step : steps) {
                Map<String, String> existing = result.putIfAbsent(step.get("key"), step);
                if (existing != null && !existing.get("label").equals(step.get("label")))
                    existing.put("label", existing.get("label") + " / " + step.get("label"));
            }
        }
        return new ArrayList<>(result.values());
    }

    private static void appendMergedSteps(List<Map<String, String>> result, String role, String keyPrefix,
            List<StepDefinition> newSteps, List<StepDefinition> revisionSteps) {
        int count = Math.max(newSteps.size(), revisionSteps.size());
        for (int index = 0; index < count; index++) {
            StepDefinition newStep = index < newSteps.size() ? newSteps.get(index) : null;
            StepDefinition revisionStep = index < revisionSteps.size() ? revisionSteps.get(index) : null;
            String key = "START".equals(role) && index == 0 ? keyPrefix : keyPrefix + "-" + (index + 1);
            Map<String, String> item = new LinkedHashMap<>();
            item.put("key", key);
            item.put("label", stepLabel(newStep, revisionStep));
            item.put("role", role);
            result.add(item);
        }
    }

    private static String stepLabel(StepDefinition newStep, StepDefinition revisionStep) {
        if (newStep == null) return revisionStep.name;
        if (revisionStep == null || newStep.name.equals(revisionStep.name)) return newStep.name;
        return newStep.name + " / " + revisionStep.name;
    }

    private static List<StepDefinition> stepsFor(FlowCatalog catalog, String role) {
        if (catalog == null) return Collections.emptyList();
        List<StepDefinition> result = new ArrayList<>();
        for (StepDefinition step : catalog.steps) if (role.equals(step.role)) result.add(step);
        return result;
    }

    private static int compareVersion(String left, String right) {
        if (left == null) {
            return right == null ? 0 : -1;
        }
        if (right == null) {
            return 1;
        }
        String[] leftParts = left.split("\\.");
        String[] rightParts = right.split("\\.");
        int size = Math.max(leftParts.length, rightParts.length);
        for (int index = 0; index < size; index++) {
            int comparison = Integer.compare(versionPart(leftParts, index), versionPart(rightParts, index));
            if (comparison != 0) {
                return comparison;
            }
        }
        return left.compareTo(right);
    }

    private static int versionPart(String[] parts, int index) {
        if (index >= parts.length) {
            return 0;
        }
        try {
            return Integer.parseInt(parts[index]);
        } catch (NumberFormatException e) {
            return 0;
        }
    }

    private static final class FlowDefinition {
        private final String key;
        private final String templateId;

        private FlowDefinition(String key, String templateId) {
            this.key = key;
            this.templateId = templateId;
        }
    }

    private static final class FlowCatalog {
        private final FlowDefinition definition;
        private final List<StepDefinition> steps;
        private final List<FormField> formFields;

        private FlowCatalog(FlowDefinition definition, List<StepDefinition> steps, List<FormField> formFields) {
            this.definition = definition;
            this.steps = steps;
            this.formFields = formFields;
        }
    }

    private static final class StepDefinition {
        private final String role;
        private final String name;

        private StepDefinition(String role, String name) {
            this.role = role;
            this.name = name;
        }
    }

    private static final class FormField {
        private final String path;
        private final String label;

        private FormField(String path, String label) {
            this.path = path;
            this.label = label;
        }
    }
}