/**
 * 流程设计器 —— 领域草稿、两种编辑器的适配，以及发布前校验。
 *
 * 领域草稿是唯一真相（《FMS工作流与审批设计》§19.4），落库时拆到
 * wf_definition / wf_version / wf_binding / wf_node / wf_edge / wf_actor_rule；
 * 画布模型（LogicFlow 的 GraphConfigData）只在编辑器里存在，不直接入库。
 *
 * 草稿形状（schemaVersion: 2，《FMS审批流程交互重构设计》§6.1）：
 * {
 *   schemaVersion: 2,
 *   definition: { id, name, i18n, enabled, remark },        // → wf_definition
 *   version:    { id, versionNo, status },                  // → wf_version
 *   bindings:   [{ id, moduleId, event, match, orgScope,     // → wf_binding
 *                  statusField, statusMap, priority,
 *                  effectiveFrom, effectiveTo, enabled }],
 *   nodes: [{ nodeKey, nodeType, name, x, y, config, actorRules }],
 *   edges: [{ edgeKey, from, to, name, condition, priority }]
 * }
 *
 * 编辑视图是递归流程树（§5.1），但它只是投影：workflowDraftToTree 派生、
 * workflowTreeToDraft 写回同一份草稿，树操作不能绕过这里自己拼 edges（§5.2.1）。
 * 无法安全表达的拓扑由投影返回 { ok: false, reason }，UI 只读保护（§3.2）。
 *
 * 坐标约定：x/y 在内存里挂在节点上（沿用现有前端形状，§6.1 的节点示例也带 x/y），
 * 但**只**经 draftToCanvasJson 写进 wf_version.b_canvas_json，绝不写进 wf_node
 * （§6.2「x/y 只进入 b_canvas_json」）。节点与连线的可执行字段一律走 wf_node / wf_edge。
 *
 * 连线条件用结构化 AST（§7.1）：null 表示默认出口，条件用 { all: [...] } / { any: [...] }
 * 表达，叶子是 { field, operator, value }，允许嵌套。前端只提交意图，SQL 由后端编译。
 */
import {
  ACTOR_NODE_TYPES,
  ACTOR_TYPES,
  APPROVAL_MODES,
  BRANCH_NODE_TYPES,
  CANVAS_TO_NODE_TYPE,
  DEPT_MANAGER_SOURCES,
  NODE_META,
  NODE_TYPE_TO_CANVAS,
  NODE_TYPES,
  OPERATORS_WITHOUT_VALUE,
  OPERATORS_WITH_LIST_VALUE,
  OPERATORS_WITH_RANGE_VALUE,
  SCHEMA_VERSION,
  VERSION_STATUS,
  conditionOperatorLabel,
} from './constants'

/** 画布上无坐标时（卡片模式新建的节点）的默认落点 */
const FALLBACK_POSITION = { baseX: 140, baseY: 240, stepX: 180 }

/* ----------------------------------------------------------------------------
   默认值
   ---------------------------------------------------------------------------- */

/**
 * 节点默认配置（对应 wf_node 的列 + b_config_json 的可执行部分）。
 * 只有人工审批节点有审批设置：抄送节点只配抄送人规则，不配审批方式（§5.3）。
 */
export function defaultNodeConfig(nodeType) {
  if (nodeType !== NODE_TYPES.USER_TASK) return {}
  return {
    approvalMode: 'single',
    rejectMode: 'terminate',
    dueHours: null,
    requiredCount: null,
    requiredRatio: null,
    // 审批行为开关（§5.2）：全部落 b_config_json，不为每个开关新增列
    allowInitiator: false,
    excludePreviousActors: true,
    allowClaim: false,
    allowTransfer: true,
    allowDelegate: true,
    allowAddApprover: true,
    commentRequired: false,
    formPolicy: { readonly: [], required: [] },
  }
}

function emptyNode(nodeType, nodeKey, x, y) {
  return {
    nodeKey,
    nodeType,
    name: NODE_META[nodeType].label,
    x,
    y,
    config: defaultNodeConfig(nodeType),
    // 审批人规则默认留空：新建节点先由校验面板提示「未配置审批人」，由使用者显式补上
    actorRules: [],
  }
}

/** 一条空的流程绑定（新建流程向导用） */
export function createBinding(moduleId = '', event = 'submit') {
  return {
    id: '',
    moduleId,
    event,
    match: null,
    orgScope: null,
    statusField: '',
    statusMap: null,
    priority: 0,
    effectiveFrom: null,
    effectiveTo: null,
    enabled: true,
  }
}

/**
 * 新建草稿：一个开始节点 + 一个结束节点，并用一条默认连线串起来，
 * 保证画布一打开就是可校验、可继续编辑的形态。
 */
export function createEmptyDraft() {
  return {
    schemaVersion: SCHEMA_VERSION,
    definition: { id: '', name: '', i18n: null, enabled: true, remark: '' },
    version: { id: '', versionNo: 1, status: 'draft' },
    bindings: [],
    nodes: [
      emptyNode(NODE_TYPES.START, 'start', FALLBACK_POSITION.baseX, FALLBACK_POSITION.baseY),
      emptyNode(NODE_TYPES.END, 'end', FALLBACK_POSITION.baseX + 480, FALLBACK_POSITION.baseY),
    ],
    edges: [{ edgeKey: 'edge_1', from: 'start', to: 'end', name: '', condition: null }],
  }
}

/**
 * 新建流程向导产出的草稿（§4.2）。
 * useTemplate 为真时按「开始 → 人工审批（未配置审批人） → 结束」建默认线性模板；
 * 为假时给空白高级流程（只有开始和结束），由使用者自己画。
 */
export function createDefinitionDraft({ id, name, moduleId, event = 'submit', useTemplate = true } = {}) {
  const draft = createEmptyDraft()
  draft.definition.id = String(id || '').trim()
  draft.definition.name = String(name || '').trim()
  draft.bindings = [createBinding(moduleId, event)]

  if (useTemplate) {
    const task = {
      ...emptyNode(NODE_TYPES.USER_TASK, 'user_task_1', FALLBACK_POSITION.baseX + 240, FALLBACK_POSITION.baseY),
      name: '审批',
    }
    draft.nodes = [draft.nodes[0], task, draft.nodes[1]]
    draft.edges = [
      { edgeKey: 'edge_1', from: 'start', to: 'user_task_1', name: '', condition: null },
      { edgeKey: 'edge_2', from: 'user_task_1', to: 'end', name: '', condition: null },
    ]
  }
  return draft
}

/** 深拷贝草稿：撤销栈与节点复制都用它，保证快照与当前草稿不共享引用 */
export function cloneDraft(draft) {
  return JSON.parse(JSON.stringify(draft ?? null))
}

/* ----------------------------------------------------------------------------
   key 生成
   ---------------------------------------------------------------------------- */

function nextKey(prefix, existing) {
  let index = 1
  while (existing.has(`${prefix}_${index}`)) index += 1
  return `${prefix}_${index}`
}

/** 生成版本内唯一的节点编码（§6.4：同一版本内 b_node_key 必须稳定） */
export function createNodeKey(nodeType, nodes = []) {
  return nextKey(nodeType, new Set(nodes.map((node) => node.nodeKey)))
}

/** 生成连线编码 */
export function createEdgeKey(edges = []) {
  return nextKey('edge', new Set(edges.map((edge) => edge.edgeKey)))
}

/** 新节点落点：在已有节点下方错开，避免叠在一起（节点面板拖拽用） */
export function nextNodePosition(nodes = []) {
  const baseX = 420
  const baseY = 140
  const step = 90
  return { x: baseX, y: baseY + (nodes.length % 6) * step }
}

/** 卡片模式插入节点时的落点：取前后两个节点的中点，切到画布时不会挤在一起 */
function positionBetween(from, to) {
  if (!from || !to) return { x: FALLBACK_POSITION.baseX, y: FALLBACK_POSITION.baseY }
  return {
    x: Math.round(((Number(from.x) || 0) + (Number(to.x) || 0)) / 2),
    y: Math.round(((Number(from.y) || 0) + (Number(to.y) || 0)) / 2) + 40,
  }
}

/* ----------------------------------------------------------------------------
   连线条件 AST（§7.1）
   ---------------------------------------------------------------------------- */

/** 条件是否为空（空对象、空数组、只有空逻辑组都算空） */
export function isConditionEmpty(condition) {
  if (!condition) return true
  if (condition.all) return !(condition.all || []).length
  if (condition.any) return !(condition.any || []).length
  if (condition.not) return isConditionEmpty(condition.not)
  return !condition.field
}

/** 规范化条件：空条件一律回落成 null（默认出口），避免存进 b_condition_json 的噪音 */
export function normalizeCondition(condition) {
  return isConditionEmpty(condition) ? null : condition
}

/** 单个条件叶子的展示文案 */
function conditionLeafText(leaf, options) {
  const label = conditionOperatorLabel(leaf.operator, options.translate)
  const field = options.fieldName ? options.fieldName(leaf.field) : leaf.field
  if (OPERATORS_WITHOUT_VALUE.includes(leaf.operator)) return `${field} ${label}`
  if (OPERATORS_WITH_RANGE_VALUE.includes(leaf.operator)) {
    const range = Array.isArray(leaf.value) ? leaf.value : []
    return `${field} ${label} ${range[0] ?? ''} ~ ${range[1] ?? ''}`
  }
  if (OPERATORS_WITH_LIST_VALUE.includes(leaf.operator)) {
    const list = Array.isArray(leaf.value) ? leaf.value : String(leaf.value ?? '').split(',')
    return `${field} ${label} ${list.filter((item) => item !== '').join('、')}`
  }
  return `${field} ${label} ${leaf.value ?? ''}`.trim()
}

function conditionText(condition, options, nested) {
  if (!condition) return ''
  const logic = condition.all ? 'all' : condition.any ? 'any' : null
  if (logic) {
    const parts = (condition[logic] || [])
      .map((item) => conditionText(item, options, true))
      .filter(Boolean)
    if (!parts.length) return ''
    const text = parts.join(logic === 'all' ? ' 且 ' : ' 或 ')
    // 顶层不套括号（连线标签本就短），嵌套组套括号保持运算优先级可读
    return nested && parts.length > 1 ? `（${text}）` : text
  }
  if (condition.not) {
    const inner = conditionText(condition.not, options, false)
    return inner ? `非（${inner}）` : ''
  }
  if (condition.field) return conditionLeafText(condition, options)
  return ''
}

/**
 * 条件 AST → 一句话（连线标签、卡片摘要、校验提示共用）。
 * @param options.translate 多语言函数，缺省回落中文
 * @param options.fieldName 字段编码 → 显示名（来自 s_field）
 */
export function describeCondition(condition, options = {}) {
  return conditionText(condition, options, false)
}

/* ----------------------------------------------------------------------------
   节点摘要（卡片模式用）
   ---------------------------------------------------------------------------- */

/** 审批方式摘要，带 N 人通过 / 按比例通过的参数 */
export function describeApprovalMode(node) {
  const config = node?.config || {}
  const mode = APPROVAL_MODES.find((item) => item.value === config.approvalMode)
  if (!mode) return ''
  if (mode.param === 'requiredCount' && config.requiredCount != null) {
    return `${mode.label} · ${config.requiredCount} 人`
  }
  if (mode.param === 'requiredRatio' && config.requiredRatio != null) {
    return `${mode.label} · ${Math.round(Number(config.requiredRatio) * 100)}%`
  }
  return mode.label
}

/** 单条审批人规则的展示文案 */
export function describeActorRule(rule, options = {}) {
  const meta = ACTOR_TYPES.find((item) => item.value === rule?.actorType)
  if (!meta) return rule?.actorType || ''
  if (meta.control === 'none') return meta.label
  if (meta.control === 'dept') {
    const source = DEPT_MANAGER_SOURCES.find((item) => item.value === rule.actorRef)
    return source ? `${meta.label}（${source.label}）` : meta.label
  }
  if (!rule.actorRef) return `${meta.label}：未选择`
  const name = options.nameOf ? options.nameOf(meta.control, rule.actorRef) : ''
  return `${meta.label}：${name || rule.actorRef}`
}

/** 节点的审批人 / 抄送人摘要 */
export function describeActorRules(node, options = {}) {
  const rules = node?.actorRules || []
  if (!rules.length) return ''
  return rules.map((rule) => describeActorRule(rule, options)).filter(Boolean).join('、')
}

/** 时限摘要 */
export function describeDue(node) {
  const hours = node?.config?.dueHours
  return hours == null || hours === '' ? '' : `时限 ${hours} 小时`
}

/** 条件摘要：连线没有名称时按条件派生标签 */
export function edgeLabel(edge, options = {}) {
  return edge?.name || describeCondition(edge?.condition, options)
}

/* ----------------------------------------------------------------------------
   边优先级

   b_priority 是「同一个来源节点内」的判断顺序（§6.5 / §5.2.3），不是全表序号。
   草稿里的 priority 只表达相对顺序，落库前统一收敛成每个来源 1..n，避免出现
   全局序号或跳号；相等时按数组位置兜底，保证结果稳定。
   ---------------------------------------------------------------------------- */

export function normalizeEdgePriorities(edges = []) {
  const bySource = new Map()
  edges.forEach((edge, index) => {
    const list = bySource.get(edge.from) || []
    list.push({ edge, index })
    bySource.set(edge.from, list)
  })

  const priorityOf = new Map()
  for (const list of bySource.values()) {
    list
      .toSorted((left, right) => {
        const diff = (Number(left.edge.priority) || 0) - (Number(right.edge.priority) || 0)
        return diff === 0 ? left.index - right.index : diff
      })
      .forEach((item, position) => priorityOf.set(item.edge.edgeKey, position + 1))
  }

  return edges.map((edge) => ({ ...edge, priority: priorityOf.get(edge.edgeKey) }))
}

/** 某个节点的出线，按判断顺序排列（树投影与校验共用同一套排序） */
export function outgoingEdgesOf(draft, nodeKey) {
  return normalizeEdgePriorities(draft?.edges || [])
    .filter((edge) => edge.from === nodeKey)
    .toSorted((left, right) => left.priority - right.priority)
}

/* ----------------------------------------------------------------------------
   数据库行 → 领域草稿

   wf_version.b_canvas_json 只放布局（节点坐标，§6.2），可执行内容在
   wf_node / wf_edge / wf_actor_rule；wf_binding 的匹配条件与状态映射存 JSON。
   ---------------------------------------------------------------------------- */

/** 宽松解析 JSON 列：脏数据不该让整个设计器打不开 */
function parseJson(text, fallback) {
  if (text === null || text === undefined || text === '') return fallback
  try {
    const value = JSON.parse(text)
    return value === null ? fallback : value
  } catch {
    return fallback
  }
}

/** 0/1、'0'/'1'、true/false 都当启用处理；空值按启用 */
function isEnabled(value) {
  if (value === null || value === undefined || value === '') return true
  return !(value === 0 || value === '0' || value === false || value === 'false')
}

function toNumberOrNull(value) {
  if (value === null || value === undefined || value === '') return null
  const number = Number(value)
  return Number.isFinite(number) ? number : null
}

/**
 * 把 wf_definition / wf_version / wf_binding / wf_node / wf_edge / wf_actor_rule
 * 的行拼成领域草稿。
 * @param {{ definition?: object, version?: object, bindings?: object[], nodes?: object[], edges?: object[], actorRules?: object[] }} rows
 */
export function rowsToWorkflowDraft(rows = {}) {
  const { definition, version, bindings = [], nodes = [], edges = [], actorRules = [] } = rows
  const canvas = parseJson(version?.b_canvas_json, {}) || {}
  const positions = canvas.nodes || {}

  // 规则按节点分组；查询已按 b_priority 排序，串行会签的顺序因此天然保留
  const rulesByNode = new Map()
  actorRules.forEach((row) => {
    const list = rulesByNode.get(row.b_node_key) || []
    list.push({
      actorType: row.b_actor_type,
      actorRef: row.b_actor_ref || '',
      resolve: parseJson(row.b_resolve_json, null),
      condition: parseJson(row.b_condition_json, null),
      fallbackType: row.b_fallback_type || 'none',
      fallbackRef: row.b_fallback_ref || '',
    })
    rulesByNode.set(row.b_node_key, list)
  })

  const draftNodes = nodes.map((row, index) => {
    const nodeType = row.b_node_type
    const extra = parseJson(row.b_config_json, {}) || {}
    const position = positions[row.b_node_key] || {}
    const config = { ...defaultNodeConfig(nodeType), ...extra }
    // 列上的值优先于 b_config_json；列为空时保留默认值，不要写成 null
    if (row.b_approval_mode) config.approvalMode = row.b_approval_mode
    if (row.b_reject_mode) config.rejectMode = row.b_reject_mode
    config.dueHours = toNumberOrNull(row.b_due_hours)

    return {
      nodeKey: row.b_node_key,
      nodeType,
      name: row.b_name || NODE_META[nodeType]?.label || row.b_node_key,
      x: Number.isFinite(position.x)
        ? position.x
        : FALLBACK_POSITION.baseX + index * FALLBACK_POSITION.stepX,
      y: Number.isFinite(position.y) ? position.y : FALLBACK_POSITION.baseY,
      config,
      actorRules: rulesByNode.get(row.b_node_key) || [],
    }
  })

  return {
    schemaVersion: SCHEMA_VERSION,
    definition: {
      id: definition?.b_id || version?.b_definition_id || '',
      name: definition?.b_name || '',
      i18n: definition?.b_i18n || null,
      enabled: isEnabled(definition?.b_canuse),
      remark: definition?.b_bz || '',
    },
    version: {
      id: version?.b_id || '',
      versionNo: Number(version?.b_version_no ?? 1),
      status: version?.b_status || 'draft',
    },
    bindings: bindings.map((row) => ({
      id: row.b_id || '',
      moduleId: row.b_module_id || '',
      event: row.b_event || 'submit',
      match: parseJson(row.b_match_json, null),
      orgScope: parseJson(row.b_org_scope_json, null),
      statusField: row.b_status_field || '',
      statusMap: parseJson(row.b_status_map_json, null),
      priority: Number(row.b_priority ?? 0),
      effectiveFrom: row.b_effective_from || null,
      effectiveTo: row.b_effective_to || null,
      enabled: isEnabled(row.b_canuse),
    })),
    nodes: draftNodes,
    // priority 是同一个来源节点上的判断顺序（§6.5），树投影按它排分支；缺值时按行序兜底
    edges: edges.map((row, index) => ({
      edgeKey: row.b_id,
      from: row.b_from_node_key,
      to: row.b_to_node_key,
      name: row.b_name || '',
      condition: normalizeCondition(parseJson(row.b_condition_json, null)),
      priority: toNumberOrNull(row.b_priority) ?? (index + 1) * 10,
    })),
  }
}

/* ----------------------------------------------------------------------------
   领域草稿 → 数据库行

   保存时把草稿拆平到各表（§6.1 转换约定）：actorRules 按顺序拆成 wf_actor_rule 行、
   用 b_priority 保存顺序，坐标单独进 b_canvas_json。字段名保持数据库原样，不在
   前端改名 —— API 封装层是边界。
   ---------------------------------------------------------------------------- */

/** 节点坐标 → wf_version.b_canvas_json（只放布局，不放可执行内容） */
export function draftToCanvasJson(draft) {
  const nodes = {}
  for (const node of draft?.nodes || []) {
    nodes[node.nodeKey] = { x: Number(node.x) || 0, y: Number(node.y) || 0 }
  }
  return { zoom: 1, nodes }
}

/**
 * 草稿 → 保存接口载荷。
 * 子表不带主键：保存接口在事务内整体替换该版本的节点 / 连线 / 规则（§6.3），
 * 主键由后端生成；连线与节点编码（b_node_key）是前端保证稳定的业务编码。
 */
export function draftToSavePayload(draft) {
  const actorRules = []
  const nodes = (draft?.nodes || []).map((node, index) => {
    const config = { ...node.config }
    const approvalMode = config.approvalMode ?? null
    const rejectMode = config.rejectMode ?? null
    const dueHours = config.dueHours ?? null
    // 列上的字段不重复塞进 b_config_json，避免两处真相
    delete config.approvalMode
    delete config.rejectMode
    delete config.dueHours

    for (const [ruleIndex, rule] of (node.actorRules || []).entries()) {
      actorRules.push({
        b_node_key: node.nodeKey,
        b_actor_type: rule.actorType,
        b_actor_ref: rule.actorRef || null,
        b_resolve_json: rule.resolve ? JSON.stringify(rule.resolve) : null,
        b_condition_json: rule.condition ? JSON.stringify(rule.condition) : null,
        b_fallback_type: rule.fallbackType || 'none',
        b_fallback_ref: rule.fallbackRef || null,
        b_priority: (ruleIndex + 1) * 10,
      })
    }

    return {
      b_node_key: node.nodeKey,
      b_name: node.name,
      b_node_type: node.nodeType,
      b_approval_mode: approvalMode,
      b_reject_mode: rejectMode,
      b_due_hours: dueHours,
      b_config_json: Object.keys(config).length ? JSON.stringify(config) : null,
      b_xh: (index + 1) * 10,
    }
  })

  return {
    schema_version: SCHEMA_VERSION,
    definition: {
      b_id: draft?.definition?.id || '',
      b_name: draft?.definition?.name || '',
      b_i18n: draft?.definition?.i18n || null,
      b_canuse: draft?.definition?.enabled === false ? 0 : 1,
      b_bz: draft?.definition?.remark || null,
    },
    version: {
      b_id: draft?.version?.id || '',
      b_definition_id: draft?.definition?.id || '',
      b_status: draft?.version?.status || 'draft',
    },
    bindings: (draft?.bindings || []).map((binding) => ({
      b_id: binding.id || null,
      b_module_id: binding.moduleId,
      b_event: binding.event,
      b_match_json: binding.match ? JSON.stringify(binding.match) : null,
      b_org_scope_json: binding.orgScope ? JSON.stringify(binding.orgScope) : null,
      b_status_field: binding.statusField || null,
      b_status_map_json: binding.statusMap ? JSON.stringify(binding.statusMap) : null,
      b_priority: Number(binding.priority) || 0,
      b_effective_from: binding.effectiveFrom || null,
      b_effective_to: binding.effectiveTo || null,
      b_canuse: binding.enabled === false ? 0 : 1,
    })),
    nodes,
    edges: normalizeEdgePriorities(draft?.edges || []).map((edge) => ({
      b_id: edge.edgeKey,
      b_from_node_key: edge.from,
      b_to_node_key: edge.to,
      b_name: edge.name || null,
      b_condition_json: edge.condition ? JSON.stringify(edge.condition) : null,
      b_priority: edge.priority * 10,
    })),
    actor_rules: actorRules,
    canvas: draftToCanvasJson(draft),
  }
}

/* ----------------------------------------------------------------------------
   领域模型 → 画布模型
   ---------------------------------------------------------------------------- */

/** LogicFlow 的 text 可能是字符串，也可能是 { value } 结构 */
function textValue(text) {
  if (text == null) return ''
  if (typeof text === 'string') return text
  return String(text.value ?? '')
}

export function workflowDomainToLogicFlow(draft, options = {}) {
  return {
    nodes: (draft?.nodes || []).map((node, index) => ({
      id: node.nodeKey,
      type: NODE_TYPE_TO_CANVAS[node.nodeType] || 'fms-user-task',
      x: Number.isFinite(node.x) ? node.x : FALLBACK_POSITION.baseX + index * FALLBACK_POSITION.stepX,
      y: Number.isFinite(node.y) ? node.y : FALLBACK_POSITION.baseY,
      text: node.name,
    })),
    edges: (draft?.edges || []).map((edge) => ({
      id: edge.edgeKey,
      type: 'polyline',
      sourceNodeId: edge.from,
      targetNodeId: edge.to,
      text: edgeLabel(edge, options),
      properties: {},
    })),
  }
}

/* ----------------------------------------------------------------------------
   画布模型 → 领域模型

   画布只管结构（谁连谁、节点在哪），业务配置（审批方式、审批人规则、条件）
   不在画布上，因此从 baseDraft 里按 nodeKey / edgeKey 回填。
   ---------------------------------------------------------------------------- */

export function logicFlowToWorkflowDraft(graph, baseDraft) {
  const baseNodes = new Map((baseDraft?.nodes || []).map((node) => [node.nodeKey, node]))
  const baseEdges = new Map((baseDraft?.edges || []).map((edge) => [edge.edgeKey, edge]))

  const nodes = (graph?.nodes || []).map((node) => {
    const nodeType = CANVAS_TO_NODE_TYPE[node.type] || NODE_TYPES.USER_TASK
    const previous = baseNodes.get(node.id)
    return {
      nodeKey: node.id,
      nodeType,
      name: textValue(node.text) || NODE_META[nodeType].label,
      x: node.x,
      y: node.y,
      config: previous ? { ...previous.config } : defaultNodeConfig(nodeType),
      actorRules: previous ? previous.actorRules.map((rule) => ({ ...rule })) : [],
    }
  })

  const edges = (graph?.edges || []).map((edge) => {
    const previous = baseEdges.get(edge.id)
    return {
      edgeKey: edge.id,
      from: edge.sourceNodeId,
      to: edge.targetNodeId,
      name: previous?.name || '',
      condition: previous?.condition ?? null,
      priority: previous?.priority ?? 0,
    }
  })

  return {
    schemaVersion: SCHEMA_VERSION,
    definition: baseDraft?.definition
      ? { ...baseDraft.definition }
      : { id: '', name: '', i18n: null, enabled: true, remark: '' },
    version: baseDraft?.version ? { ...baseDraft.version } : { id: '', versionNo: 1, status: 'draft' },
    bindings: (baseDraft?.bindings || []).map((binding) => ({ ...binding })),
    nodes,
    edges,
  }
}

/* ----------------------------------------------------------------------------
   单链路（卡片模式）判定与图操作（§3.1 / §8.3）
   ---------------------------------------------------------------------------- */

function groupByEndpoint(edges, key) {
  const map = new Map()
  for (const edge of edges) {
    const list = map.get(edge[key]) || []
    list.push(edge)
    map.set(edge[key], list)
  }
  return map
}

/** 单链路判定的失败结果 */
function notLinear(reason) {
  return { linear: false, reason, order: [] }
}

/**
 * 判定草稿能否用卡片模式编辑，并给出主链路顺序。
 * 单链路 = 只有一个开始节点、除开始结束外每个节点出入各一条、不含分支/服务节点、无环。
 * @returns {{ linear: boolean, reason: string, order: string[] }}
 */
export function inspectLinear(draft) {
  const nodes = draft?.nodes || []
  const edges = draft?.edges || []

  const starts = nodes.filter((node) => node.nodeType === NODE_TYPES.START)
  const ends = nodes.filter((node) => node.nodeType === NODE_TYPES.END)
  if (starts.length !== 1) return notLinear('流程必须有且只有一个开始节点')
  if (!ends.length) return notLinear('流程缺少结束节点')

  const branch = nodes.find((node) => BRANCH_NODE_TYPES.includes(node.nodeType))
  if (branch) {
    return notLinear(
      `存在「${NODE_META[branch.nodeType]?.label || branch.nodeType}」节点，只能到高级画布编辑`,
    )
  }

  const out = groupByEndpoint(edges, 'from')
  const inc = groupByEndpoint(edges, 'to')
  for (const node of nodes) {
    const outList = out.get(node.nodeKey) || []
    const inList = inc.get(node.nodeKey) || []
    if (node.nodeType === NODE_TYPES.END) {
      if (outList.length) return notLinear(`结束节点「${node.name}」不应有出线`)
    } else if (outList.length > 1) {
      return notLinear(`节点「${node.name}」有多条出线`)
    }
    if (node.nodeType !== NODE_TYPES.START && inList.length > 1) {
      return notLinear(`节点「${node.name}」有多条入线`)
    }
  }

  const order = []
  const seen = new Set()
  let current = starts[0].nodeKey
  while (current) {
    if (seen.has(current)) return notLinear('流程存在环形路径')
    seen.add(current)
    order.push(current)
    current = (out.get(current) || [])[0]?.to
  }

  if (order.length !== nodes.length) {
    const missing = nodes.find((node) => !seen.has(node.nodeKey))
    return notLinear(`节点「${missing?.name || ''}」不在主链路上`)
  }
  const last = nodes.find((node) => node.nodeKey === order[order.length - 1])
  if (last?.nodeType !== NODE_TYPES.END) return notLinear('主链路没有走到结束节点')

  return { linear: true, reason: '', order }
}

/** 主链路上的节点对象数组（非单链路时返回空数组） */
export function listLinearSteps(draft) {
  const info = inspectLinear(draft)
  if (!info.linear) return []
  const byKey = new Map((draft.nodes || []).map((node) => [node.nodeKey, node]))
  return info.order.map((key) => byKey.get(key)).filter(Boolean)
}

/**
 * 按给定顺序重建连线（§8.3 写图规则）。
 * 连线按位置复用原有编码与名称，节点顺序变化不影响连线数量以外的东西。
 * 这是插入 / 删除 / 移动 / 复制四个操作的共同底座。
 */
function applyLinearOrder(draft, orderedKeys) {
  const byKey = new Map((draft.nodes || []).map((node) => [node.nodeKey, node]))
  const ordered = orderedKeys.map((key) => byKey.get(key)).filter(Boolean)
  const needed = Math.max(0, ordered.length - 1)
  const edges = []
  for (let index = 0; index < needed; index += 1) {
    const source = draft.edges[index]
    edges.push({
      edgeKey: source?.edgeKey || createEdgeKey([...draft.edges, ...edges]),
      from: ordered[index].nodeKey,
      to: ordered[index + 1].nodeKey,
      name: source?.name || '',
      condition: source?.condition ?? null,
    })
  }
  return { ...draft, edges }
}

function findNode(draft, nodeKey) {
  return (draft?.nodes || []).find((node) => node.nodeKey === nodeKey) || null
}

/**
 * 在 fromKey 与其后继之间插入一个节点：A → B 变成 A → 新节点 → B。
 * @returns {{ draft: object, ok: boolean, reason?: string, nodeKey?: string }}
 */
export function insertLinearStep(draft, fromKey, nodeType) {
  const info = inspectLinear(draft)
  if (!info.linear) return { draft, ok: false, reason: info.reason }
  const index = info.order.indexOf(fromKey)
  if (index < 0 || index >= info.order.length - 1) {
    return { draft, ok: false, reason: '插入位置无效' }
  }

  const nodeKey = createNodeKey(nodeType, draft.nodes)
  const from = findNode(draft, fromKey)
  const to = findNode(draft, info.order[index + 1])
  const node = { ...emptyNode(nodeType, nodeKey, 0, 0), ...positionBetween(from, to) }
  const order = [...info.order.slice(0, index + 1), nodeKey, ...info.order.slice(index + 1)]
  return {
    draft: applyLinearOrder({ ...draft, nodes: [...draft.nodes, node] }, order),
    ok: true,
    nodeKey,
  }
}

/** 删除节点：A → B → C 变成 A → C；带分支的节点交给高级模式 */
export function removeLinearStep(draft, nodeKey) {
  const info = inspectLinear(draft)
  if (!info.linear) return { draft, ok: false, reason: info.reason }
  const node = findNode(draft, nodeKey)
  if (!node) return { draft, ok: false, reason: '节点不存在' }
  if (NODE_META[node.nodeType]?.fixed) {
    return { draft, ok: false, reason: `${NODE_META[node.nodeType].label}节点不能删除` }
  }
  const order = info.order.filter((key) => key !== nodeKey)
  return {
    draft: applyLinearOrder(
      { ...draft, nodes: draft.nodes.filter((item) => item.nodeKey !== nodeKey) },
      order,
    ),
    ok: true,
  }
}

/** 上移 / 下移（offset 为 -1 / 1）：只改主链路顺序，画布布局与 b_xh 跟着重排 */
export function moveLinearStep(draft, nodeKey, offset) {
  const info = inspectLinear(draft)
  if (!info.linear) return { draft, ok: false, reason: info.reason }
  const index = info.order.indexOf(nodeKey)
  if (index < 0) return { draft, ok: false, reason: '节点不存在' }
  const target = index + offset
  // 开始与结束是固定端点，不参与换位
  if (target < 0 || target >= info.order.length) return { draft, ok: false, reason: '已经到头了' }
  const neighbour = findNode(draft, info.order[target])
  if (NODE_META[neighbour?.nodeType]?.fixed || NODE_META[findNode(draft, nodeKey)?.nodeType]?.fixed) {
    return { draft, ok: false, reason: '开始与结束节点位置固定' }
  }

  const order = [...info.order]
  order[index] = info.order[target]
  order[target] = info.order[index]
  return { draft: applyLinearOrder(draft, order), ok: true }
}

/** 复制节点并插在它后面：配置与审批人规则一起复制，编码重新生成 */
export function duplicateLinearStep(draft, nodeKey) {
  const info = inspectLinear(draft)
  if (!info.linear) return { draft, ok: false, reason: info.reason }
  const source = findNode(draft, nodeKey)
  if (!source) return { draft, ok: false, reason: '节点不存在' }
  if (NODE_META[source.nodeType]?.fixed) {
    return { draft, ok: false, reason: `${NODE_META[source.nodeType].label}节点不能复制` }
  }

  const nodeKey2 = createNodeKey(source.nodeType, draft.nodes)
  const clone = {
    ...cloneDraft(source),
    nodeKey: nodeKey2,
    name: `${source.name}（副本）`,
    x: (Number(source.x) || 0) + FALLBACK_POSITION.stepX,
  }
  const index = info.order.indexOf(nodeKey)
  const order = [...info.order.slice(0, index + 1), nodeKey2, ...info.order.slice(index + 1)]
  return {
    draft: applyLinearOrder({ ...draft, nodes: [...draft.nodes, clone] }, order),
    ok: true,
    nodeKey: nodeKey2,
  }
}

/* ----------------------------------------------------------------------------
   流程树投影（《FMS审批流程设置器交互重构设计》§5.1 / §5.2）

   锁定的执行契约（阶段 0 产出）：后端流程服务尚未实现，树形交互需要的网关语义先在这里
   定义清楚并用测试锁死，接入后逐项验收，不在组件里各猜一套。
     1. 一个条件块 = 一个 exclusive_gateway；每条出边 = 一个分支，按 b_priority 升序判断；
     2. 恰有一条 condition 为 null 的出边，是「其他情况」，投影里固定排最后；
     3. 每个分支有专属子路径；所有分支在「最近的公共后继」汇合，该节点是条件块的 next；
        各分支各自走到结束、没有公共后继时 next 为 null，结束节点留在各自分支里；
     4. 分支优先级在投影内连续唯一，写回时按此顺序生成 b_priority。

   树只是编辑投影：它是 draft.nodes / edges 的派生视图，变更必须经 workflowTreeToDraft
   写回同一份草稿（§5.2.8），不新增第二套持久化结构、不改 wf_* 语义。
   投影不成立时返回 { ok: false, reason }，UI 据此只读保护，绝不压平或丢边保存（§3.2）。
   ---------------------------------------------------------------------------- */

/** 树形编辑器能安全表达的节点类型 */
export const TREE_NODE_TYPES = [
  NODE_TYPES.START,
  NODE_TYPES.USER_TASK,
  NODE_TYPES.CC_TASK,
  NODE_TYPES.EXCLUSIVE_GATEWAY,
  NODE_TYPES.END,
]

/** 深层递归里发现无法表达的拓扑时中断构树 */
class UnsupportedTopologyError extends Error {
  constructor(message, nodeKey = null) {
    super(message)
    this.name = 'UnsupportedTopologyError'
    this.nodeKey = nodeKey
  }
}

function unsupported(reason, nodeKey = null) {
  return { ok: false, reason, nodeKey }
}

/** 从 startKey 出发能到达的全部节点（含自身） */
function descendantsOf(startKey, outMap) {
  const seen = new Set()
  const stack = [startKey]
  while (stack.length) {
    const key = stack.pop()
    if (seen.has(key)) continue
    seen.add(key)
    for (const edge of outMap.get(key) || []) stack.push(edge.to)
  }
  return seen
}

/**
 * 各分支的最近公共后继。
 * @returns {string|null|undefined} 汇合点编码；没有公共后继返回 null；汇合点不唯一返回 undefined
 */
function findMerge(targets, outMap) {
  const sets = targets.map((key) => descendantsOf(key, outMap))
  const shared = [...sets[0]].filter((key) => sets.every((set) => set.has(key)))
  if (!shared.length) return null

  const reach = new Map(shared.map((key) => [key, descendantsOf(key, outMap)]))
  const candidates = shared.filter(
    (key) => !shared.some((other) => other !== key && reach.get(other).has(key)),
  )
  return candidates.length === 1 ? candidates[0] : undefined
}

/**
 * 领域草稿 → 递归流程树（§5.1 的 FlowItem）。
 * @returns {{ ok: true, tree: object, signature: string } | { ok: false, reason: string, nodeKey: string|null }}
 */
export function workflowDraftToTree(draft) {
  const nodes = draft?.nodes || []
  const byKey = new Map(nodes.map((node) => [node.nodeKey, node]))

  const outMap = new Map()
  for (const edge of normalizeEdgePriorities(draft?.edges || [])) {
    if (!byKey.has(edge.from) || !byKey.has(edge.to)) {
      return unsupported('存在两端节点已不存在的连线')
    }
    outMap.set(edge.from, [...(outMap.get(edge.from) || []), edge])
  }
  for (const list of outMap.values()) list.sort((left, right) => left.priority - right.priority)

  const starts = nodes.filter((node) => node.nodeType === NODE_TYPES.START)
  if (starts.length !== 1) return unsupported('流程必须有且只有一个开始节点')
  if (!nodes.some((node) => node.nodeType === NODE_TYPES.END)) return unsupported('流程缺少结束节点')

  // 节点类型与出入度：树形表达不了的一律拒绝，不做压平猜测（§3.2 / §5.2.7）
  // 注意只约束出边（§5.2.6）：入边不限制 —— 分支汇合点天生就有多条入线，
  // 把入度锁成 1 会把「分支后公共审批」这种正常流程误判成不可表达。
  for (const node of nodes) {
    const outList = outMap.get(node.nodeKey) || []
    const label = node.name || node.nodeKey

    if (!TREE_NODE_TYPES.includes(node.nodeType)) {
      return unsupported(
        `存在「${NODE_META[node.nodeType]?.label || node.nodeType}」节点，树形编辑器无法安全表达`,
        node.nodeKey,
      )
    }
    if (node.nodeType === NODE_TYPES.START) {
      if (outList.length !== 1) return unsupported('开始节点必须有且只有一条出线', node.nodeKey)
      if (outList[0].condition) return unsupported('开始节点的出线不应带条件', node.nodeKey)
      continue
    }
    if (node.nodeType === NODE_TYPES.END) {
      if (outList.length) return unsupported('结束节点不应有出线', node.nodeKey)
      continue
    }
    if (node.nodeType === NODE_TYPES.EXCLUSIVE_GATEWAY) {
      if (outList.length < 2) return unsupported(`条件分支「${label}」至少要有两条分支`, node.nodeKey)
      const defaults = outList.filter((edge) => !edge.condition)
      if (defaults.length !== 1) {
        return unsupported(
          `条件分支「${label}」必须有且仅有一个「其他情况」分支（当前 ${defaults.length} 个）`,
          node.nodeKey,
        )
      }
      continue
    }
    if (outList.length !== 1) return unsupported(`节点「${label}」必须有且只有一条出线`, node.nodeKey)
    if (outList[0].condition) {
      return unsupported(`节点「${label}」不是条件分支，其出线不应带条件`, node.nodeKey)
    }
  }

  // 环：出边约束下环只能经由网关形成，必须在构树前拦掉，否则递归不终止
  const cycle = findCycle(nodes, draft?.edges || [])
  if (cycle) return unsupported(`流程存在环形路径（${cycle}），树形编辑器无法安全表达`)

  // 可达性：从开始出发必须覆盖全部节点
  const reachable = descendantsOf(starts[0].nodeKey, outMap)
  if (reachable.size !== nodes.length) {
    const orphan = nodes.find((node) => !reachable.has(node.nodeKey))
    return unsupported(
      `节点「${orphan?.name || ''}」不在主流程上，树形编辑器无法安全表达`,
      orphan?.nodeKey || null,
    )
  }

  const visiting = new Set()
  const build = (nodeKey, stopKey = null) => {
    if (!nodeKey || nodeKey === stopKey) return null
    if (visiting.has(nodeKey)) {
      throw new UnsupportedTopologyError('流程存在环形路径，树形编辑器无法安全表达', nodeKey)
    }
    visiting.add(nodeKey)
    try {
      return buildItem(nodeKey, stopKey)
    } finally {
      visiting.delete(nodeKey)
    }
  }

  const buildItem = (nodeKey, stopKey) => {
    const node = byKey.get(nodeKey)
    if (!node) return null

    if (node.nodeType === NODE_TYPES.EXCLUSIVE_GATEWAY) {
      const branchEdges = outMap.get(nodeKey) || []
      const targets = branchEdges.map((edge) => edge.to)
      const merge = findMerge(targets, outMap)
      if (merge === undefined) {
        throw new UnsupportedTopologyError(
          `条件分支「${node.name}」的分支汇合点不唯一，树形编辑器无法安全表达`,
          nodeKey,
        )
      }
      // 交叉边：某条分支的入口落在另一条分支的专属路径里，会和「分支汇合」语义冲突
      const crossed = targets.find((target) =>
        targets.some(
          (other) =>
            other !== target && target !== merge && descendantsOf(other, outMap).has(target),
        ),
      )
      if (crossed) {
        throw new UnsupportedTopologyError(
          `条件分支「${node.name}」存在交叉连线（分支入口「${byKey.get(crossed)?.name || crossed}」在另一条分支里），树形编辑器无法安全表达`,
          nodeKey,
        )
      }

      // 显式条件保持相对顺序，「其他情况」固定排最后（§5.2.3）；优先级归一化成显示顺序
      const ordered = [
        ...branchEdges.filter((edge) => edge.condition),
        ...branchEdges.filter((edge) => !edge.condition),
      ]
      return {
        kind: 'branch',
        gatewayKey: nodeKey,
        branches: ordered.map((edge, index) => ({
          edgeKey: edge.edgeKey,
          label: edge.name || '',
          priority: index + 1,
          condition: edge.condition ?? null,
          child: build(edge.to, merge),
        })),
        next: merge ? build(merge, stopKey) : null,
      }
    }

    const nextEdge = (outMap.get(nodeKey) || [])[0]
    return { kind: 'step', nodeKey, next: nextEdge ? build(nextEdge.to, stopKey) : null }
  }

  let tree
  try {
    tree = build(starts[0].nodeKey)
  } catch (error) {
    if (error instanceof UnsupportedTopologyError) return unsupported(error.message, error.nodeKey)
    throw error
  }

  return { ok: true, tree, signature: treeSignature(tree) }
}

/** 结构签名：只含拓扑、编码、条件与优先级，不含坐标 —— 用于往返一致性断言 */
export function treeSignature(tree) {
  const walk = (item) => {
    if (!item) return null
    if (item.kind === 'step') return { s: item.nodeKey, next: walk(item.next) }
    return {
      g: item.gatewayKey,
      b: item.branches.map((branch) => ({
        e: branch.edgeKey,
        p: branch.priority,
        c: describeCondition(branch.condition),
        child: walk(branch.child),
      })),
      next: walk(item.next),
    }
  }
  return JSON.stringify(walk(tree))
}

/** 某个 FlowItem 的入口节点：分支块的入口是它的网关 */
function entryKeysOf(item) {
  if (!item) return []
  return item.kind === 'branch' ? [item.gatewayKey] : [item.nodeKey]
}

/**
 * 递归流程树 → 领域草稿（§5.2.8：写回同一份草稿，语义与 wf_* 保持不变）。
 *
 * 节点与连线的编码优先复用 baseDraft 里已有的（§6.3：编码在本版本内必须稳定）：
 * 同名关系（from→to 相同）复用原 edgeKey，分支边直接复用分支自己的 edgeKey，
 * 因此「加载 → 构树 → 编译」不会产生编码漂移。
 *
 * @param tree workflowDraftToTree 产出的树，或经树操作修改过的树
 * @param baseDraft 原草稿，提供定义/版本/绑定与已有节点配置
 * @param extraNodes 树里新引入、baseDraft 中还没有的节点定义（树操作新增节点时传入）
 */
export function workflowTreeToDraft(tree, baseDraft, extraNodes = []) {
  const knownNodes = new Map(
    [...(baseDraft?.nodes || []), ...extraNodes].map((node) => [node.nodeKey, node]),
  )
  const baseEdges = new Map((baseDraft?.edges || []).map((edge) => [edge.edgeKey, edge]))

  const nodes = []
  const edges = []
  const usedEdgeKeys = new Set()

  // 同名关系（from→to）的旧编码池：编译时优先复用，保证编码稳定
  const pairPool = new Map()
  for (const edge of baseDraft?.edges || []) {
    const pair = `${edge.from}->${edge.to}`
    pairPool.set(pair, [...(pairPool.get(pair) || []), edge.edgeKey])
  }

  const ensureNode = (nodeKey) => {
    if (nodes.some((node) => node.nodeKey === nodeKey)) return
    const known = knownNodes.get(nodeKey)
    // 未知节点按人工审批兜底：宁可留下一个待配置节点，也不静默丢结构
    nodes.push(known ? cloneDraft(known) : emptyNode(NODE_TYPES.USER_TASK, nodeKey, 0, 0))
  }

  const takeEdgeKey = (from, to) => {
    const pair = `${from}->${to}`
    const pool = pairPool.get(pair) || []
    const reused = pool.shift()
    pairPool.set(pair, pool)
    return reused || createEdgeKey([...(baseDraft?.edges || []), ...edges])
  }

  const addEdge = (from, to, condition, priority, preferredKey) => {
    const edgeKey =
      preferredKey && !usedEdgeKeys.has(preferredKey) ? preferredKey : takeEdgeKey(from, to)
    usedEdgeKeys.add(edgeKey)
    const base = baseEdges.get(edgeKey)
    edges.push({
      edgeKey,
      from,
      to,
      name: base?.name || '',
      condition: condition ?? null,
      priority,
    })
  }

  /** 编译一个子树，返回它还需要接入父级后续的「出口节点」 */
  const compile = (item) => {
    if (!item) return []

    if (item.kind === 'step') {
      ensureNode(item.nodeKey)
      if (!item.next) return [item.nodeKey]
      const entries = entryKeysOf(item.next)
      const exits = compile(item.next)
      entries.forEach((toKey) => addEdge(item.nodeKey, toKey, null, 1))
      return exits
    }

    ensureNode(item.gatewayKey)
    const branchExits = []
    item.branches.forEach((branch, index) => {
      const entries = entryKeysOf(branch.child)
      const childExits = compile(branch.child)
      const targets = entries.length ? entries : entryKeysOf(item.next)

      if (!targets.length) {
        // 既没有子节点也没有公共后续：保留原边，绝不静默丢边（§5.2.7）
        const base = baseEdges.get(branch.edgeKey)
        if (base) {
          usedEdgeKeys.add(base.edgeKey)
          edges.push({ ...base, condition: branch.condition ?? base.condition ?? null, priority: index + 1 })
        }
        return
      }
      targets.forEach((toKey, position) => {
        addEdge(item.gatewayKey, toKey, branch.condition, index + 1, position === 0 ? branch.edgeKey : null)
      })
      if (entries.length) branchExits.push(...childExits)
    })

    if (!item.next) return branchExits
    const nextEntries = entryKeysOf(item.next)
    const nextExits = compile(item.next)
    branchExits.forEach((fromKey) => {
      nextEntries.forEach((toKey) => addEdge(fromKey, toKey, null, 1))
    })
    return nextExits
  }

  compile(tree)

  return {
    schemaVersion: SCHEMA_VERSION,
    definition: baseDraft?.definition
      ? { ...baseDraft.definition }
      : { id: '', name: '', i18n: null, enabled: true, remark: '' },
    version: baseDraft?.version ? { ...baseDraft.version } : { id: '', versionNo: 1, status: 'draft' },
    bindings: (baseDraft?.bindings || []).map((binding) => ({ ...binding })),
    nodes,
    edges: normalizeEdgePriorities(edges),
  }
}

/* ----------------------------------------------------------------------------
   发布前校验

   §9.2「发布前必须再次执行服务端校验」里前端能判定的部分；后端在保存与发布时会
   再校验一次，这里只是即时反馈（《FMS工作流与审批设计》§19.6）。
   ---------------------------------------------------------------------------- */

function issue(level, message, nodeKey = null) {
  return { level, message, nodeKey }
}

/** 从开始节点出发能走到的节点集合 */
function reachableFrom(startKey, edges) {
  const seen = new Set()
  const queue = [startKey]
  while (queue.length) {
    const current = queue.shift()
    if (seen.has(current)) continue
    seen.add(current)
    edges.filter((edge) => edge.from === current).forEach((edge) => queue.push(edge.to))
  }
  return seen
}

/** 有向图找环（返回任意一个环上的节点编码，用于提示） */
function findCycle(nodes, edges) {
  const out = groupByEndpoint(edges, 'from')
  const state = new Map()
  let hit = null
  const walk = (key, path) => {
    if (hit) return
    const current = state.get(key)
    if (current === 'visiting') {
      hit = path.slice(path.indexOf(key)).join(' → ')
      return
    }
    if (current === 'done') return
    state.set(key, 'visiting')
    for (const edge of out.get(key) || []) walk(edge.to, [...path, edge.to])
    state.set(key, 'done')
  }
  for (const node of nodes) walk(node.nodeKey, [node.nodeKey])
  return hit
}

/** 条件里用到的字段编码 */
function conditionFields(condition, result = []) {
  if (!condition) return result
  for (const logic of ['all', 'any']) {
    if (condition[logic]) condition[logic].forEach((item) => conditionFields(item, result))
  }
  if (condition.not) conditionFields(condition.not, result)
  if (condition.field) result.push(condition.field)
  return result
}

/**
 * 校验领域草稿。
 * @param options.fieldCodes 绑定模块可用字段编码集合（来自 s_field）；不传则跳过字段存在性校验
 * @returns {{ level: 'error'|'warn', message: string, nodeKey: string|null }[]}
 */
export function validateWorkflowDomain(draft, options = {}) {
  const nodes = draft?.nodes || []
  const edges = draft?.edges || []
  const bindings = draft?.bindings || []
  const issues = []
  const push = (level, message, nodeKey = null) => issues.push(issue(level, message, nodeKey))
  const nodeKeys = new Set(nodes.map((node) => node.nodeKey))
  const fieldCodes = options.fieldCodes ? new Set(options.fieldCodes) : null

  /* 流程定义与绑定（§6.2 / §9.2） */
  if (!String(draft?.definition?.id || '').trim()) push('error', '流程编码为空')
  if (!String(draft?.definition?.name || '').trim()) push('error', '流程名称为空')
  if (!bindings.length) {
    push('error', '未配置流程绑定：流程无法被任何业务单据触发')
  }
  bindings.forEach((binding, index) => {
    const label = `绑定 ${index + 1}`
    if (!binding.moduleId) push('error', `${label}：未选择业务模块`)
    if (!binding.event) push('error', `${label}：未选择业务事件`)
    if (binding.effectiveFrom && binding.effectiveTo && binding.effectiveFrom > binding.effectiveTo) {
      push('error', `${label}：生效开始时间晚于结束时间`)
    }
  })
  // 同一模块 + 事件的多个启用绑定，最终由后端按条件与优先级择一，前端只能提示复核
  const bindingGroups = new Map()
  bindings
    .filter((binding) => binding.enabled !== false && binding.moduleId && binding.event)
    .forEach((binding) => {
      const key = `${binding.moduleId}|${binding.event}`
      bindingGroups.set(key, (bindingGroups.get(key) || 0) + 1)
    })
  bindingGroups.forEach((count, key) => {
    if (count > 1) {
      push('warn', `模块 ${key.split('|')[0]} 的事件存在 ${count} 条启用绑定，需确认条件与优先级不会冲突`)
    }
  })

  /* 结构（§6.2） */
  if (nodeKeys.size !== nodes.length) push('error', '存在重复的节点编码')

  const starts = nodes.filter((node) => node.nodeType === NODE_TYPES.START)
  if (!starts.length) {
    push('error', '缺少开始节点')
  } else if (starts.length > 1) {
    push('error', `存在 ${starts.length} 个开始节点，只允许一个`, starts[1].nodeKey)
  }

  const ends = nodes.filter((node) => node.nodeType === NODE_TYPES.END)
  if (!ends.length) push('error', '缺少结束节点')

  edges.forEach((edge) => {
    if (!nodeKeys.has(edge.from) || !nodeKeys.has(edge.to)) {
      push('error', '存在两端节点已不存在的连线')
    }
  })

  if (starts.length) {
    const reachable = reachableFrom(starts[0].nodeKey, edges)
    nodes.forEach((node) => {
      if (!reachable.has(node.nodeKey)) {
        push('warn', `节点「${node.name}」从开始节点不可达`, node.nodeKey)
      }
    })
  }

  const cycle = findCycle(nodes, edges)
  if (cycle) push('error', `存在环形路径：${cycle}`)

  /* 出入度（§5.2.6：树形编辑器支持的流程里，开始/审批/抄送必须恰有一条出边，结束没有出边） */
  nodes.forEach((node) => {
    const outgoing = outgoingEdgesOf(draft, node.nodeKey)
    if (node.nodeType === NODE_TYPES.END) {
      if (outgoing.length) push('error', `结束节点「${node.name}」不应有出线`, node.nodeKey)
      return
    }
    if (!outgoing.length) {
      push('error', `节点「${node.name}」没有出线，流程会卡在这里`, node.nodeKey)
      return
    }
    if (node.nodeType !== NODE_TYPES.EXCLUSIVE_GATEWAY && outgoing.length > 1) {
      push('error', `节点「${node.name}」有多条出线，只有条件分支可以分支`, node.nodeKey)
    }
  })

  /* 节点配置（§6.4 / §6.6 / §9.2） */
  nodes
    .filter((node) => ACTOR_NODE_TYPES.includes(node.nodeType))
    .forEach((node) => {
      const who = node.nodeType === NODE_TYPES.CC_TASK ? '抄送人' : '审批人'
      const rules = node.actorRules || []
      if (!rules.length) {
        push('error', `「${node.name}」未配置${who}规则`, node.nodeKey)
        return
      }
      rules.forEach((rule) => {
        const meta = ACTOR_TYPES.find((item) => item.value === rule.actorType)
        if (!meta) {
          push('error', `「${node.name}」存在未知的${who}解析类型`, node.nodeKey)
          return
        }
        if (meta.control === 'none') return
        if (!rule.actorRef) {
          push('error', `「${node.name}」的${meta.label}规则未选择具体对象`, node.nodeKey)
          return
        }
        if (meta.control === 'field' && fieldCodes && !fieldCodes.has(rule.actorRef)) {
          push('error', `「${node.name}」引用的字段 ${rule.actorRef} 不在绑定模块的字段里`, node.nodeKey)
        }
      })

      // 自审风险（§9.2）：只有人工审批节点才谈得上「申请人自审」，抄送发起人自己是正常的
      if (
        node.nodeType === NODE_TYPES.USER_TASK &&
        rules.some((rule) => rule.actorType === 'initiator') &&
        !node.config?.allowInitiator
      ) {
        push('warn', `「${node.name}」把发起人作为审批人，但未开启「允许申请人自审」`, node.nodeKey)
      }

      const config = node.config || {}
      if (config.approvalMode === 'n_of_m') {
        const count = Number(config.requiredCount)
        if (!Number.isFinite(count) || count <= 0) {
          push('error', `「${node.name}」选择 N 人通过但未填写通过人数`, node.nodeKey)
        }
      }
      if (config.approvalMode === 'percentage') {
        const ratio = Number(config.requiredRatio)
        if (!Number.isFinite(ratio) || ratio <= 0 || ratio > 1) {
          push('error', `「${node.name}」的通过比例必须在 0 到 1 之间`, node.nodeKey)
        }
      }
      const dueHours = config.dueHours
      if (dueHours != null && dueHours !== '' && !(Number(dueHours) > 0)) {
        push('error', `「${node.name}」的审批时限必须大于 0`, node.nodeKey)
      }
    })

  nodes
    .filter((node) => BRANCH_NODE_TYPES.includes(node.nodeType))
    .forEach((node) => {
      if (node.nodeType !== NODE_TYPES.EXCLUSIVE_GATEWAY) {
        push('warn', `「${node.name}」在第一阶段仅占位，发布后不会执行`, node.nodeKey)
      }
    })

  /* 连线条件（§5.2.3 / §5.2.6 / §6.5 / §7.1） */
  nodes
    .filter((node) => node.nodeType === NODE_TYPES.EXCLUSIVE_GATEWAY)
    .forEach((node) => {
      const outgoing = outgoingEdgesOf(draft, node.nodeKey)
      if (!outgoing.length) {
        push('error', `条件分支「${node.name}」没有出线`, node.nodeKey)
        return
      }
      if (outgoing.length < 2) {
        push('error', `条件分支「${node.name}」至少要有两条分支`, node.nodeKey)
      }
      const defaults = outgoing.filter((edge) => !edge.condition)
      if (!defaults.length) {
        push('error', `条件分支「${node.name}」缺少默认出口（需且仅需一条无条件连线）`, node.nodeKey)
      } else if (defaults.length > 1) {
        push('error', `条件分支「${node.name}」有 ${defaults.length} 条默认出口，只允许一条`, node.nodeKey)
      }
      // 原始 b_priority 重复时判断顺序只能退化成连线顺序（保存时按规范重排），提示复核
      const rawPriorities = edges
        .filter((edge) => edge.from === node.nodeKey)
        .map((edge) => Number(edge.priority) || 0)
      if (new Set(rawPriorities).size !== rawPriorities.length) {
        push('warn', `条件分支「${node.name}」的分支优先级有重复，将按连线顺序确定判断顺序`, node.nodeKey)
      }
      // 显式条件按优先级依次判断，「其他情况」必须排在最后（§5.2.3）
      if (defaults.length === 1 && outgoing[outgoing.length - 1].condition) {
        push('warn', `条件分支「${node.name}」的「其他情况」不在最后，保存时会按规范重排`, node.nodeKey)
      }
    })

  edges.forEach((edge) => {
    const from = nodes.find((node) => node.nodeKey === edge.from)
    if (edge.condition && from && from.nodeType !== NODE_TYPES.EXCLUSIVE_GATEWAY) {
      push('error', `「${from.name}」不是条件分支，其出线不应带条件`, from.nodeKey)
    }
    for (const field of conditionFields(edge.condition)) {
      if (fieldCodes && !fieldCodes.has(field)) {
        push('error', `连线条件引用的字段 ${field} 不在绑定模块的字段里`)
      }
    }
    walkConditionIssues(edge.condition, push)
  })

  return issues
}

/** 条件叶子本身的完整性（缺字段、缺操作符、缺比较值） */
function walkConditionIssues(condition, push) {
  if (!condition) return
  for (const logic of ['all', 'any']) {
    if (condition[logic]) condition[logic].forEach((item) => walkConditionIssues(item, push))
  }
  if (condition.not) walkConditionIssues(condition.not, push)
  if (!condition.field) {
    if (!condition.all && !condition.any && !condition.not) push('error', '存在缺少字段的条件')
    return
  }
  if (!condition.operator) {
    push('error', `条件字段 ${condition.field} 未选择操作符`)
    return
  }
  if (OPERATORS_WITHOUT_VALUE.includes(condition.operator)) return
  if (OPERATORS_WITH_RANGE_VALUE.includes(condition.operator)) {
    const range = Array.isArray(condition.value) ? condition.value : []
    if (range.filter((item) => item !== '' && item != null).length < 2) {
      push('error', `条件字段 ${condition.field} 的区间不完整`)
    }
    return
  }
  if (OPERATORS_WITH_LIST_VALUE.includes(condition.operator)) {
    const list = Array.isArray(condition.value) ? condition.value : []
    if (!list.length) push('error', `条件字段 ${condition.field} 未填写比较值`)
    return
  }
  if (condition.value === '' || condition.value == null) {
    push('error', `条件字段 ${condition.field} 未填写比较值`)
  }
}

/** 版本状态文案（列表与工具栏共用） */
export function versionStatusLabel(status) {
  return VERSION_STATUS.find((item) => item.value === status)?.label || status || ''
}